Repository: oppia/oppia-android
Pull request #5723: Fix #2746 and Fix part of #1723: Update Onboarding Instructions and Bazel Documentation
Author: login: adhiamboperes
Labels: name: PR: LGTM
Created: 2025-02-26T20:10:22Z | Merged: 2025-03-26T23:41:16Z

Fix #2746:

- Remove gradle specific instructions, reorganize setup order, add instructions for running app and tests.
- Audit existing Bazel setup instructions and expand where necessary.
-  Installing the Bazel plugin in Android Studio
-  Syncing (& partial syncing)

Fix part of #1723:
- Ensure the installation instructions provide support for folks both using emulators and physical Android devices

**Other changes**
- Removed steps for setting up a Rosetta terminal because that was only required for modifying Gradle's `local.properties` file.
- `noexperimental_check_desugar_deps` flag is nolonger required. In Bazel 4, this was required to disable `[--experimental_check_desugar_deps](https://docs.bazel.build/versions/master/command-line-reference.html#flag--experimental_check_desugar_deps), which had several incompatibilities with the Apple Silicon Chip. For more information, please see [here](https://blog.bazel.build/2018/12/19/bazel-0.21.html#android).

## Essential Checklist
<!-- Please tick the relevant boxes by putting an "x" in them. -->
- [x] The PR title and explanation each start with "Fix #bugnum: " (If this PR fixes part of an issue, prefix the title with "Fix part of #bugnum: ...".)
- [ ] Any changes to [scripts/assets](https://github.com/oppia/oppia-android/tree/develop/scripts/assets) files have their rationale included in the PR explanation.
- [x] The PR follows the [style guide](https://github.com/oppia/oppia-android/wiki/Coding-style-guide).
- [x] The PR does not contain any unnecessary code changes from Android Studio ([reference](https://github.com/oppia/oppia-android/wiki/Guidance-on-submitting-a-PR#undo-unnecessary-changes)).
- [x] The PR is made from a branch that's **not** called "develop" and is up-to-date with "develop".
- [x] The PR is **assigned** to the appropriate reviewers ([reference](https://github.com/oppia/oppia-android/wiki/Guidance-on-submitting-a-PR#clarification-regarding-assignees-and-reviewers-section)).

## For UI-specific PRs only
N/A

Linked issue #2746: Add documentation for Android Studio with Bazel on all OS's
We should expand our Bazel documentation to include:

- [x] - Installing the Bazel plugin in Android Studio https://github.com/oppia/oppia-android/pull/5723
- [x] - Importing the project as a Bazel project https://github.com/oppia/oppia-android/pull/5723
- [x] - Syncing (& partial syncing)
- [x] - Building the app https://github.com/oppia/oppia-android/pull/5723
- [x] - Building & running tests through AS https://github.com/oppia/oppia-android/pull/5723

----

Also, per #3371 Bazel development support is very limited on Windows. Per #3437 we should investigate the viability of setting up a VM and running both Android Studio and Bazel from the same Unix-based environment (to avoid a bifurcation where the repo lives in Windows and the user does development via Windows Android Studio, but uses Bazel within an Ubuntu subsystem). This involves documenting the steps below for Windows:

- [x] - Using git to clone & modify Oppia Android
- [x] - Running Android Studio
- [x] - Building & running tests via Bazel (CLI) https://github.com/oppia/oppia-android/pull/5723
- [x] - Deploying the app binary & tests to a real device https://github.com/oppia/oppia-android/pull/5723
- [x] - Starting an emulator https://github.com/oppia/oppia-android/pull/5723
- [x] - Deploying the app binary & tests to an emulator https://github.com/oppia/oppia-android/pull/5723
Linked issue comments: user: login: FareesHussain
created_at: 2021-02-27T12:34:54Z
body: > * Installing the Bazel plugin in Android Studio

Regarding this, I've followed these steps.

 - Downloaded plugin from [jetbrains](https://plugins.jetbrains.com/plugin/9185-bazel/versions) Version: 2021.01.06.0.1 (Latest versions gives errors)
 - Open Files -> settings -> plugin -> select the preferences icon on the top right -> install from disk -> select the downloaded plugin -> Restart IDE


But on selecting the bazel on the option disappears. 
I guess we need to import the project as a bazel project for that.

> * Importing the project as a Bazel project

For this after installing the BAZEL plugin

- Import bazel project (File -> Import Bazel Project ..)
- Select oppia-android (~/opensource/oppia-android if followed the steps from the wiki)
- Generate from BUILD file (~/opensource/oppia-android/BUILD.bazel)
- Uncomment Kotlin and the one SDK platform
- And a new project was opened (~/opensource/oppia-android/.aswb)

But there are a bunch of error in the bazel console (bazel sync fails and I guess we can't proceed after this)
I think it is using the default installed bazel and we need oppia-bazel here

@BenHenning @fsharpasharp Do we have to wait for a new release for this or make changes in the [plugin](https://github.com/bazelbuild/intellij) or Am I using a wrong approach here.

Making `oppia-bazel` default as `bazel` does work but is this a correct solution
 

author_association: CONTRIBUTOR
user: login: FareesHussain
created_at: 2021-02-27T12:59:32Z
body: > But there are a bunch of error in the bazel console (bazel sync fails and I guess we can't proceed after this)
> I think it is using the default installed bazel and we need oppia-bazel here

To fix this I've replaced the installed bazel with oppia-bazel and then when I try to sync the project I get this error
*tried with both check and uncheck Expand Sync to Working Set*

Created a [gist](https://gist.github.com/FareesHussain/2763b717b7b571bb8671dacc3cf9c38e) of the targets which gives the error (errors encountered while analyzing target)
```
ERROR: command succeeded, but not all targets were analyzed
INFO: Elapsed time: 1.092s, Critical Path: 0.01s
INFO: 0 processes.
FAILED: Build did NOT complete successfully
FAILED: Build did NOT complete successfully
INFO: Build Event Protocol files produced successfully.
FAILED: Build did NOT complete successfully
build invocation result: build_error
Sync was successful, but there were Bazel build errors. The project may not be fully updated or resolve until fixed. If the errors are from your working set, please uncheck 'Bazel > Sync > Expand Sync to Working Set' and try again.

```
author_association: CONTRIBUTOR
user: login: BenHenning
created_at: 2021-03-15T20:17:41Z
body: There's a new issue affecting Android Studio: https://github.com/bazelbuild/rules_proto/issues/78 (see linked protoc issue for details). I might try sending a patch to rules_proto to see if it's an easy fix just to bump the version to 3.14.
author_association: MEMBER
user: login: BenHenning
created_at: 2021-03-15T21:48:16Z
body: Confirming this is an issue with version 2021.01.06.0.1 of the Bazel plugin. Updating rules_proto to a later version doesn't seem to fix the issue. I think the issue is actually within the Bazel plugin--it's not being built with compatibility for JDK 8. In the meantime I'm going to see if downgrading to an earlier version of the plugin fixes the issue.
author_association: MEMBER
user: login: BenHenning
created_at: 2021-03-16T00:23:14Z
body: https://github.com/bazelbuild/intellij/issues/2265 is tracking the plugin-specific issue.
author_association: MEMBER
user: login: BenHenning
created_at: 2021-03-16T01:18:26Z
body: Confirming that the custom plugin suggested in that thread does work for us: https://github.com/hedronvision/bazelbuild-intellij/releases/tag/v2021.02.03.

@fsharpasharp FYI since this is definitely going to cause some friction when trying to get Bazel working in Android Studio.
author_association: MEMBER
user: login: FareesHussain
created_at: 2021-05-26T19:58:14Z
body: I've tried using the latest version of bazel plugin (2021.04.27.0.0) for the to build using bazel. 

I've created a [gist](https://gist.github.com/FareesHussain/2ee5749f3d4e30c03820ae9270358d85) for the errors I've encountered.
author_association: CONTRIBUTOR
user: login: BenHenning
created_at: 2021-05-27T03:02:30Z
body: Ah, that might be a different error @FareesHussain. Could you add your .bazelproject file to a Gist & link that here? Also, which Android SDK do you have installed on your system?
author_association: MEMBER
user: login: FareesHussain
created_at: 2021-05-27T03:07:33Z
body: Here is the [gist](https://gist.github.com/FareesHussain/c7a2652bb23af72eb223844d37a7501b)

the plugin showed SDK 29 and 30 as available and I selected 30 
author_association: CONTRIBUTOR
user: login: FareesHussain
created_at: 2021-06-02T02:50:27Z
body: > Confirming that the custom plugin suggested in that thread does work for us: https://github.com/hedronvision/bazelbuild-intellij/releases/tag/v2021.02.03.
> 
> @fsharpasharp FYI since this is definitely going to cause some friction when trying to get Bazel working in Android Studio.

![image](https://user-images.githubusercontent.com/54740946/120416734-40c55500-c37b-11eb-8069-0b8c5e044c04.png)
 
I was trying to install from disk by downloading the [build](https://github.com/hedronvision/bazelbuild-intellij/releases/download/v2021.02.03/aswb_bazel.zip) but it gives the above error
author_association: CONTRIBUTOR

Diff:
diff --git a/wiki/Bazel-Setup-Instructions-for-Linux.md b/wiki/Bazel-Setup-Instructions-for-Linux.md
deleted file mode 100644
index f0dceb51c9f..00000000000
--- a/wiki/Bazel-Setup-Instructions-for-Linux.md
+++ /dev/null
@@ -1,75 +0,0 @@
-## Instructions
-
-**The steps to install Bazel on Linux are:**
-1. Install Bazel
-2. Set up the ANDROID_HOME environment variable
-3. Verify the Android build
-
-### 1. Install Bazel
-
-Install Bazel from [here](https://docs.bazel.build/versions/master/install.html). Make sure that you follow the instructions for installing a specific version (Oppia Android requires 6.5.0 and won't build on other versions).
-   - Note: if you find any errors related to `cURL`, please set up cURL on your machine. For Linux, you can use `sudo apt install curl`.
-
-### 2. Set up the ANDROID_HOME environment variable
-
-Ensure that your `ANDROID_HOME` environment variable is set to the location of your Android SDK. To do this, find the path to the installed SDK using Android Studio’s SDK Manager (install SDK 28). Assuming the SDK is installed to default locations, you can use the following commands to set the `ANDROID_HOME` variable:<br>
-   ```
-   export ANDROID_HOME=$HOME/Android/Sdk/
-   ```
-
-**Make sure you have the system environment variable set up** for ``ANDROID_HOME`` as you might have issues getting properly set up if not. If it isn’t set up (on Linux you can check by using ``echo $ANDROID_HOME`` in a new terminal; it should output the correct path to your Android SDK), on Linux you can move the ``export`` from above to your ``~/.bashrc`` file to make it permanent (you can apply the change immediately using ``source ~/.bashrc``).
-
-### 3. Verifying the build
-
-At this point, your system should be able to build Oppia Android. To verify, try building the APK (from your subsystem terminal -- note that this and all other Bazel commands must be run from the root of the ‘oppia-android’ directory otherwise they will fail):
-
-```
-bazel build //:oppia_dev
-```
-
-(Note that this command may take 10-20 minutes to complete depending on the performance of your machine).
-
-If everything is working, you should see output like the following:
-
-```
-Target //:oppia_dev up-to-date:
-  bazel-bin/oppia_dev.aab
-INFO: Elapsed time: ...
-INFO: 1 process...
-INFO: Build completed successfully, ...
-```
-
-Note also that the ``oppia_dev.aab`` under the ``bazel-bin`` directory of your local copy of Oppia Android should be a fully functioning development version of the app that can be installed using bundle-tool. However, it's recommended to deploy Oppia to an emulator or connected device using the following Bazel command:
-
-```sh
-bazel mobile-install //:oppia_dev_binary
-```
-
-``mobile-install`` is much faster for local development (especially for the developer flavor of the app) because it does more sophisticated dex regeneration detection for faster incremental installs. See https://bazel.build/docs/mobile-install for details.
-
-**Note**: If you run into a failure like the following when trying to use `mobile-install` to a device running SDK 34 or newer:
-
-```
-FATAL EXCEPTION: main
- Process: org.oppia.android, PID: 9508
-    java.lang.RuntimeException: Unable to instantiate application com.google.devtools.build.android.incrementaldeployment.StubApplication package org.oppia.android: java.lang.SecurityException: Writable dex file '/data/local/tmp/incrementaldeployment/org.oppia.android/dex/incremental_classes4.dex' is not allowed.
-     at android.app.LoadedApk.makeApplicationInner(LoadedApk.java:1466)
-     at android.app.LoadedApk.makeApplicationInner(LoadedApk.java:1395)
-     at android.app.ActivityThread.handleBindApplication(ActivityThread.java:6959)
-     at android.app.ActivityThread.-$$Nest$mhandleBindApplication(Unknown Source:0)
-     at android.app.ActivityThread$H.handleMessage(ActivityThread.java:2236)
-     at android.os.Handler.dispatchMessage(Handler.java:106)
-     at android.os.Looper.loopOnce(Looper.java:205)
-     at android.os.Looper.loop(Looper.java:294)
-     at android.app.ActivityThread.main(ActivityThread.java:8177)
-     at java.lang.reflect.Method.invoke(Native Method)
-     at com.android.internal.os.RuntimeInit$MethodAndArgsCaller.run(RuntimeInit.java:552)
-     at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:971)
-    Caused by: java.lang.SecurityException: Writable dex file '/data/local/tmp/incrementaldeployment/org.oppia.android/dex/incremental_classes4.dex' is not allowed.
-```
-
-Then you will need to use `adb install` directly:
-
-```sh
-adb install bazel-bin/oppia_dev_binary.apk
-```
diff --git a/wiki/Bazel-Setup-Instructions-for-Mac.md b/wiki/Bazel-Setup-Instructions-for-Mac.md
deleted file mode 100644
index eaf97c4f39e..00000000000
--- a/wiki/Bazel-Setup-Instructions-for-Mac.md
+++ /dev/null
@@ -1,103 +0,0 @@
-## Bazel Set up for Mac including Apple silicon (M1/M2) chips
-
-## Instructions
-
-**The steps to install Bazel on Mac are:**
-1. Set up Rosetta Terminal
-2. Install Bazel
-3. Set Bazel and ANDROID_HOME paths permanently in your terminal
-4. Verify that the build is working
-
-### 1. Set up Rosetta Terminal
-
-- In the Finder app on your Mac, locate the Applications folder from the favorites sidebar.
-- Right-click on your Terminal app and create a duplicate Terminal (and rename it accordingly, say **Terminal Rosetta**, to avoid confusion).
-- On the newly created Terminal Rosetta icon, right-click and select "Get info", and under “General”, check the option "Open using Rosetta".
-
-**Note: Always use the Rosetta terminal for Bazel setup and running `bash setup.sh` or any Bazel build-related commands.**
-
-### 2. Install Bazel
-
-1. Install Bazel following the instructions [here](https://docs.bazel.build/versions/4.0.0/install-os-x.html#install-with-installer-mac-os-x). Make sure that you follow the instructions for installing a specific version (Oppia Android requires 6.5.0 and won't build on other versions).
-
-2. That’s it, now Bazel is installed, and you can verify it by running the command:
-   ```
-   bazel --version
-   ```
-   - **Expected Output**
-   ```
-   bazel 6.5.0
-   ```
-
-### 3. Set Bazel and ANDROID_HOME paths permanently in your terminal
-
-- To set the `Bazel` and `ANDROID_HOME` path permanently in your terminal run these commands:
-    ```
-    sudo nano /etc/paths
-    ```
-   - Enter your password, when prompted.
-   - Go to the bottom of the file, and enter these paths
-     ```
-     /Users/{YourMacUserName}/bin
-     $HOME/Library/Android/sdk
-     ```
-   - Hit control-x to quit.
-   - Enter “Y” to save the modified buffer.
-   - That’s it!  To test it, in a new terminal window, type: `echo $PATH`
-
-**Note: You must set the path for `Bazel` and `ANDROID_HOME` before running bazel build for oppia-android, otherwise you will get an error.**
-
-### 4. Verify that the build is working
-
-At this point, your system should be able to build Oppia Android. To verify, try building the APK (from your subsystem terminal -- note that this and all other Bazel commands must be run from the root of the ‘oppia-android’ directory otherwise they will fail):
-
-```
-bazel build //:oppia_dev
-```
-
-(Note that this command may take 10-20 minutes to complete depending on the performance of your machine).
-
-If everything is working, you should see output like the following:
-
-```
-Target //:oppia_dev up-to-date:
-  bazel-bin/oppia_dev.aab
-INFO: Elapsed time: ...
-INFO: 1 process...
-INFO: Build completed successfully, ...
-```
-
-Note also that the ``oppia_dev.aab`` under the ``bazel-bin`` directory of your local copy of Oppia Android should be a fully functioning development version of the app that can be installed using bundle-tool. However, it's recommended to deploy Oppia to an emulator or connected device using the following Bazel command:
-
-```sh
-bazel mobile-install //:oppia_dev_binary
-```
-
-``mobile-install`` is much faster for local development (especially for the developer flavor of the app) because it does more sophisticated dex regeneration detection for faster incremental installs. See https://bazel.build/docs/mobile-install for details.
-
-**Note**: If you run into a failure like the following when trying to use `mobile-install` to a device running SDK 34 or newer:
-
-```
-FATAL EXCEPTION: main
- Process: org.oppia.android, PID: 9508
-    java.lang.RuntimeException: Unable to instantiate application com.google.devtools.build.android.incrementaldeployment.StubApplication package org.oppia.android: java.lang.SecurityException: Writable dex file '/data/local/tmp/incrementaldeployment/org.oppia.android/dex/incremental_classes4.dex' is not allowed.
-     at android.app.LoadedApk.makeApplicationInner(LoadedApk.java:1466)
-     at android.app.LoadedApk.makeApplicationInner(LoadedApk.java:1395)
-     at android.app.ActivityThread.handleBindApplication(ActivityThread.java:6959)
-     at android.app.ActivityThread.-$$Nest$mhandleBindApplication(Unknown Source:0)
-     at android.app.ActivityThread$H.handleMessage(ActivityThread.java:2236)
-     at android.os.Handler.dispatchMessage(Handler.java:106)
-     at android.os.Looper.loopOnce(Looper.java:205)
-     at android.os.Looper.loop(Looper.java:294)
-     at android.app.ActivityThread.main(ActivityThread.java:8177)
-     at java.lang.reflect.Method.invoke(Native Method)
-     at com.android.internal.os.RuntimeInit$MethodAndArgsCaller.run(RuntimeInit.java:552)
-     at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:971)
-    Caused by: java.lang.SecurityException: Writable dex file '/data/local/tmp/incrementaldeployment/org.oppia.android/dex/incremental_classes4.dex' is not allowed.
-```
-
-Then you will need to use `adb install` directly:
-
-```sh
-adb install bazel-bin/oppia_dev_binary.apk
-```
diff --git a/wiki/Bazel-Setup-Instructions-for-Windows.md b/wiki/Bazel-Setup-Instructions-for-Windows.md
deleted file mode 100644
index 6145791a6a3..00000000000
--- a/wiki/Bazel-Setup-Instructions-for-Windows.md
+++ /dev/null
@@ -1,207 +0,0 @@
-## Table of Contents
-
-- [Overview & Disclaimer](#overview--disclaimer)
-- [Instructions](#instructions)
-  - [1. Install Ubuntu subsystem](#1-install-ubuntu-subsystem)
-  - [2. Prerequisite debian packages](#2-prerequisite-debian-packages)
-  - [3. Installing the Android SDK](#3-installing-the-android-sdk)
-  - [4. Installing Bazel](#4-installing-bazel)
-  - [5. Preparing build environment for Oppia Android](#5-preparing-build-environment-for-oppia-android)
-  - [6. Verifying the build](#6-verifying-the-build)
-  - [7. Next steps](#7-next-steps)
-- [Appendix](#appendix)
-  - [Limitations](#limitations)
-
-## Overview & Disclaimer
-
-This page outlines one way to allow Bazel to be used in CLI form on Windows. Please note that **this support is currently experimental**. You may run into some problems--we suggest that you [file an issue](https://github.com/oppia/oppia-android/issues/new/choose) or contact us at [github-discussions](https://github.com/oppia/oppia-android/discussions).
-
-Unlike Unix-based systems where Bazel runs natively without issue, the current solution on Windows is to install an Ubuntu-based subsystem. Windows currently only supports a terminal experience in this subsystem (though there is a prerelease version of the software with GUI support) which means Android Studio will not be supported. You will need to continue using the Windows version of Android Studio and only use the Linux subsystem for building & running Robolectric or JUnit-based tests.
-
-## Instructions
-
-**Main prerequisites**:
-- Windows 10: These instructions are geared towards users of Windows 10 (older versions will not be compatible). If you're in using an older version of Windows, please follow up with a comment on [this issue](https://github.com/oppia/oppia-android/issues/3371).
-- At least 4GB of free local disk storage space (for Linux & needed dependencies), but more will probably help when building the app
-
-Also, note that these instructions *replace* the standard Oppia Bazel [set-up instructions](https://github.com/oppia/oppia-android/wiki/Oppia-Bazel-Setup-Instructions) since different steps are required for Windows with an Ubuntu subsystem.
-
-At a high-level, the steps to make Bazel work on Windows are:
-1. Install the Ubuntu subsystem
-2. Install prerequisite debian packages
-3. Install the Android SDK
-4. Install Bazel
-5. Set up the environment to be able to build Oppia Android
-6. Verify that the build is working
-7. Run Bazel commands as needed during development
-
-### 1. Install Ubuntu subsystem
-
-Please follow Microsoft's [setup instructions](https://docs.microsoft.com/en-us/windows/wsl/install-win10) to set up the Linux subsystem on Windows 10. From there, you should install **Ubuntu** (the instructions below are based on the apt package manager on Ubuntu; other Linux distributions & package managers may work but they are untested by the team).
-
-Once installed, open the Ubuntu terminal from the start menu.
-
-### 2. Prerequisite debian packages
-
-From within the Ubuntu terminal, start by ensuring all packages are up-to-date:
-
-```sh
-sudo apt update && sudo apt upgrade
-```
-
-After that, follow each of the subsections below as needed to install prerequisite dependencies:
-
-**Installing JDK 17+**
-
-Setting up Bazel for Oppia Android requires JDK>=17 for [Android Package Manager](#3-installing-the-android-sdk).
-
-For Ubuntu systems, this can be set up using:
-
-```sh
-sudo apt install openjdk-17-jdk
-```
-
-For Fedora 25+, this can be set up using:
-
-```
-sudo dnf install java-17-openjdk
-```
-
-**GCC**
-
-Install gcc using the following command:
-
-```sh
-sudo apt install gcc
-```
-
-### 3. Installing the Android SDK
-
-We need to be able to run Linux-compatible Android utilities which requires installing a Linux version of the Android SDK. Since we can't install Android Studio in the subsystem, we need to do this via CLI commands. The steps below are extracted from [this article](https://proandroiddev.com/how-to-setup-android-sdk-without-android-studio-6d60d0f2812a).
-
-First, prepare the environment for the SDK by creating the default directory to hold the SDK (from within Ubuntu terminal):
-
-```sh
-mkdir -p $HOME/Android/Sdk
-```
-
-Second, navigate to https://developer.android.com/studio#command-tools in a web browser (in Windows) and select to download the latest **Linux** command tools (even though you're using Windows, the Linux commandline tools are needed--the Windows version will not work with these instructions). Once downloaded, copy the zip file to the new SDK location (note that the ``/mnt/c/...`` path is based on ``C:\Users\<Name>\Downloads`` being the default download location--this may not be the case on your system) with your Windows username filled in for ``<Name>``:
-
-```sh
-cp /mnt/c/Users/<Name>/Downloads/commandlinetools*.zip $HOME/Android/Sdk
-```
-
-After that, change to the directory, unzip the archive, and remove it:
-
-```sh
-cd $HOME/Android/Sdk
-unzip commandlinetools*.zip
-rm commandlinetools*.zip
-```
-
-From there, the command line tools need to be moved in order to indicate to the tools themselves that they're relative to the Android SDK root directory:
-
-```sh
-cd cmdline-tools/
-mkdir tools
-mv -i * tools
-cd ..
-```
-
-(The above may give a warning for the ``mv`` command since it will try moving ``tools`` into ``tools``--this can be ignored).
-
-At this point, we can define the ``ANDROID_HOME`` variable to point to the new SDK root, and also update the ``PATH`` to point to cmdnline-tools so that we can actually install the SDK. To do this, run the following commands to append new lines to ``~/.bashrc``:
-
-```sh
-echo "export ANDROID_HOME=\$HOME/Android/Sdk" >> ~/.bashrc
-echo "export PATH=\$ANDROID_HOME/cmdline-tools/tools/bin/:\$PATH" >> ~/.bashrc
-source ~/.bashrc
-```
-
-(The last line reloads your Bash configuration file so that the variable adjustments above become live in your local terminal).
-
-The ``sdkmanager`` command can now be used to install the necessary packages. Run each of the following commands in succession (you may need to accept licenses for the SDK packages in the same way you would when using Android Studio):
-
-```sh
-sdkmanager
-sdkmanager --install "platform-tools"
-sdkmanager --install "platforms;android-33"
-sdkmanager --install "build-tools;32.0.0"
-```
-
-When the commands above are finished running, the Android SDK should now be installed in your subsystem & be accessible to Bazel.
-
-### 4. Installing Bazel
-
-Follow [these instructions](https://docs.bazel.build/versions/main/install-ubuntu.html#install-on-ubuntu) to install Bazel using ``apt`` rather than Bazelisk (Bazelisk might work, but it's untested with these instructions). Note that Oppia requires Bazel 6.5.0, so you'll likely need to run the following command:
-
-```sh
-sudo apt install bazel-6.5.0
-```
-
-#### For Fedora 25+
-
-- Install Bazelisk instead of Bazel using the command below in Fedora:
-```
-wget https://github.com/bazelbuild/bazelisk/releases/download/v1.8.1/bazelisk-linux-amd64
-chmod +x bazelisk-linux-amd64
-sudo mv bazelisk-linux-amd64 /usr/local/bin/bazel
-```
-
-### 5. Preparing build environment for Oppia Android
-
-The Oppia Android repository generally expects to live under an 'opensource' directory. While we recommend doing that in practice, we run into one complication when building the app on Windows: the repository itself lives under the native Windows filesystem & most of everything else needed to build lives under the Linux subsystem. To help simplify things, we prefer keeping just the repository on Windows and everything else on Linux, including the the Oppia Bazel toolchain. To prepare for this, we suggest making an 'opensource' directory in your Ubuntu subsystem:
-
-```sh
-mkdir $HOME/opensource
-cd $HOME/opensource
-```
-
-Clone the [oppia-android](https://github.com/oppia/oppia-android) repository into the opensource directory.
-
-```sh
-git clone https://github.com/oppia/oppia-android.git
-```
-
-To configure your development environment and set up essential tools, execute the following setup script from the oppia-android directory.
-
-```sh
-scripts/setup.sh
-```
-
-### 6. Verifying the build
-
-At this point, your system should be able to build Oppia Android. To verify, try building the APK (from your subsystem terminal -- note that this & all other Bazel commands must be run from the root of the ‘oppia-android’ directory otherwise they will fail):
-
-```sh
-bazel build //:oppia_dev
-```
-
-(Note that this command may take 10-20 minutes to complete depending on the performance of your machine).
-
-If everything is working, you should see output like the following:
-
-```
-Target //:oppia_dev up-to-date:
-  bazel-bin/oppia_dev.aab
-INFO: Elapsed time: ...
-INFO: 1 process...
-INFO: Build completed successfully, ...
-```
-
-If you see the above, you can proceed to use your subsystem for Bazel commands while developing Oppia. If you instead see an error, please [file an issue](https://github.com/oppia/oppia-android/issues/new/choose).
-
-Note also that the ``oppia.apk`` under the ``bazel-bin`` directory of your local copy of Oppia Android should be a fully functioning development version of the app that can be installed using ``adb`` (though we recommend using ADB from within a Windows command prompt or shell since the Ubuntu subsystem may not have correct support to access devices or emulators connected to the native Windows machine).
-
-### 7. Next steps
-
-At this point, commands listed on the other [Bazel setup instructions](https://github.com/oppia/oppia-android/wiki/Oppia-Bazel-Setup-Instructions#building-the-app) page should now work locally. Keep in mind that your development will continue on Windows via Android Studio and that the subsystem is only needed to execute Bazel commands (Gradle should continue to work through Windows).
-
-## Appendix
-
-### Limitations
-Known limitations with using an Ubuntu subsystem on Windows:
-- Android Studio must run on native Windows: this is a current limitation. However, https://github.com/microsoft/wslg is a WIP project that may provide an alternative option which allows full development to take place within the subsystem.
-- The subsystem is very slow: unfortunately, this is just a limitation with how the subsystem works on Windows. Until we fix the actual build pipeline to work natively, this is likely going to be a limitation that we have to live with. Note that installing an Ubuntu VM or dual-booting Ubuntu may lead to less issues & better performance than using a subsystem, but this hasn't yet been investigated or documented yet (see [#3437](https://github.com/oppia/oppia-android/issues/3437) for the WIP issue).
-- ADB is limited within the subsystem and thus must be used from within a Windows CLI like Command Prompt, Powershell, or Git Bash (if it's installed) in order to deploy the Bazel-built test or APK binary to an emulator or real device
-- Emulators likely cannot be launched from the subsystem (headless might be possible, but this hasn't been tested)
diff --git a/wiki/Bazel-User-Guide.md b/wiki/Bazel-User-Guide.md
new file mode 100644
index 00000000000..a83f7a93113
--- /dev/null
+++ b/wiki/Bazel-User-Guide.md
@@ -0,0 +1,286 @@
+## Table of Contents
+
+- [Overview](#overview)
+- [Installation](#installation)
+  - [Building the app](#building-the-app)
+- [Running Tests](#running-tests)
+  - [How to Obtain a Test Target](#how-to-obtain-a-test-target)
+  - [Common Flags](#common-flags)
+  - [Running multiple test targets](#running-multiple-test-targets)
+- [Concepts and Terminology](#concepts-and-terminology)
+- [Syncing the Project](#syncing-the-project)
+
+## Overview
+Bazel is an open-source build and test tool similar to Make, Maven, and Gradle. It uses a human-readable, high-level build language.
+
+Oppia Android leverages Bazel for its efficient, scalable builds and reliable performance across various environments, making it well-suited for our large-scale project.
+
+## Installation
+
+Follow the instructions on the [installation page](https://github.com/oppia/oppia-android/wiki/Installing-Oppia-Android#install-bazel) to set up Bazel.
+
+### Building the app
+
+The [installation page](https://github.com/oppia/oppia-android/wiki/Installing-Oppia-Android#install-bazel) provides information on running the project in Android Studio.
+
+You can also run the app from the command line using the commands detailed below.
+
+Using the command line is helpful in instances when you need to build and run some targets outside of Android Studio.
+
+Run the following commands in your terminal. All Bazel commands must be run from the root of the `oppia-android` directory otherwise they will fail.
+
+Note that on the first run, these commands may take 10-20 minutes to complete depending on the performance of your machine. Subsequent runs will be much faster.
+
+**On SDK 29 and below, run**:
+   ```
+   bazel mobile-install //:oppia_dev_binary
+   ```
+This will build, install and launch the app on your device.
+
+**On SDK 30 and newer, run**:
+   ```
+   bazel build //:oppia_dev
+   ```
+followed by:
+   ```
+   adb install bazel-bin/oppia_dev_binary.apk  
+   ```
+* Starting from SDK 30, incremental builds, like those executed using `bazel mobile-install`, are no longer permitted, necessitating the use of two separate commands.
+
+If everything is working, you should see output like the following:
+
+```
+Target //:oppia_dev_binary up-to-date:
+  bazel-bin/oppia_dev_binary_deploy.jar
+  bazel-bin/oppia_dev_binary_unsigned.apk
+  bazel-bin/oppia_dev_binary.apk
+INFO: Elapsed time: 37.155s, Critical Path: 17.24s
+INFO: 99 processes: 2 internal, 23 darwin-sandbox, 74 worker.
+INFO: Build completed successfully, 99 total actions
+Performing Streamed Install
+Success
+```
+
+Note also that the ``oppia_dev.aab`` under the ``bazel-bin`` directory of your local copy of Oppia Android should be a fully functioning development version of the app that can be installed using bundle-tool. However, it's recommended to deploy Oppia to an emulator or connected device using the `mobile-install` command.
+
+## Running Tests
+
+The bazel test command is used to build and run tests in a Bazel workspace. It ensures that the specified test targets are built and executed in a sandboxed environment for reproducibility.
+
+**Syntax**
+
+```shell
+bazel test //path/to:target
+```
+
+### How to Obtain a Test Target
+A test target in Bazel refers to a specific testable entity defined in a BUILD file. It represents a test rule, such as `java_test` or `android_test`, that Bazel can build and execute.
+
+To ensure you always use the correct test target, follow one of these steps:
+1. If the test file is open in Android Studio:
+   * Right-click to open the context menu and select **Copy BUILD target string** as shown.
+     
+     ![Screenshot 2025-03-18 at 22 30 22](https://github.com/user-attachments/assets/286ebcb6-4f4e-4055-b6f0-4c070b039375)
+   
+   * Paste the target to the bazel test command, e.g. `bazel test //domain/src/test/java/org/oppia/android/domain/onboarding:AppStartupStateControllerTest`
+
+2. If the test file is open in Android Studio, but **Copy BUILD target string** is not available in the context menu:
+Sometimes, the **Copy BUILD target string** is not available in the context menu either due to sync issues or modularization issues. You can still copy the file path, and pass it to the test command.
+   * In the AS sidebar, right click on the file, and select `copy path/reference`.
+     or
+   * Right-click on the file tab and then click `copy path/reference`.
+   * Next, select `copy path from repository root`. 
+   * Paste the copied path to the bazel test command in the terminal and remove the `.kt` extension, e.g. `bazel test domain/src/test/java/org/oppia/android/domain/onboarding/AppStartupStateControllerTest`.
+
+With this syntax, Bazel implicitly converts the file path into a target if it matches a test rule in the BUILD file. If the file is not part of a test target in the BUILD file, this command may fail.
+**When to use this**: If you are unsure about the exact Bazel target and want a quick way to run a test.
+
+3. Querying for a target
+Using the explicit Bazel target (// syntax) is more reliable compared to the file path syntax above. However, in cases such as running the test outside android studio, you may not know the target. In this case, you can use Bazel's `query` command to retrieve the correct test target:
+   * Copy the relative path of the test file.
+   * Run the following command in your terminal to get the test’s Bazel target: `bazel query relative-path-of-test-file`
+   Example
+   
+   ```shell
+   bazel query domain/src/test/java/org/oppia/android/domain/onboarding/AppStartupStateControllerTest.kt
+   ```
+   * The output will be a Bazel target that starts with //. Copy the target and remove the .kt extension.
+   * Use this target in the bazel test command, e.g. `bazel test //domain/src/test/java/org/oppia/android/domain/onboarding:AppStartupStateControllerTest`.
+
+### Common Flags
+
+`--test_output=all` → Show full test output.
+`--cache_test_results=no` → Force re-running tests even if cached.
+`--test_filter=ClassName#methodName` → Run specific test cases.
+`--runs_per_test=100` → Specifies number of times to run each test.
+
+### Running multiple test targets
+To run all the test targets in the app module:
+
+```
+bazel test //app/...
+```
+
+To run all the test targets in the project (note that this would be extremely slow and is not recommended):
+
+```
+bazel test //...
+```
+
+To run multiple test targets at once:
+
+```
+bazel test -- //path/to/target/FirstTest //path/to/target/SecondTest
+```
+
+## Concepts and Terminology
+**[Workspace](https://github.com/oppia/oppia-android/blob/7344270032ac242b1b8987f1b51c8b5aa4f14ce3/WORKSPACE#L2)**
+
+A workspace is a directory where we specify the targeted SDK version, required dependencies, and corresponding Rules. The directory containing the WORKSPACE file is the root of the main repository, which in our case, is the `oppia-android` root directory.
+**[Packages](https://github.com/oppia/oppia-android/tree/develop/app)**
+
+A package is defined as a directory containing a file named BUILD or BUILD.bazel.
+
+**[Binary rules](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/BUILD.bazel#L3)**
+
+A rule specifies the relationship between inputs and outputs, and the steps to build the outputs.
+In Android, rules are defined using `android_binary`. Android rules for testing are `android_instrumentation_test` and `android_local_test`.
+
+**[BUILD files](https://github.com/oppia/oppia-android/blob/7344270032ac242b1b8987f1b51c8b5aa4f14ce3/app/BUILD.bazel#L3)**
+
+Every package contains a BUILD file. This file is written in Starlark Language. In this Build file for module-level, we generally define `android_library`, `kt_android_library` to build our package files as per the requirement.
+
+**[Dependencies](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/BUILD.bazel#L16)**
+
+A target A depends upon a target B, if B is needed by A at build. `A -> B`
+
+```
+deps = [ "//app",]
+```
+Here, `deps` is used to define the dependencies which is a type of dependencies called `deps dependencies` and it includes the files/directory/target which are dependent. From the above example, the dependency is the `app` target which is defined in the [Build file of app package](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/app/BUILD.bazel#L616).
+
+Example of Dependencies
+1. [srcs dependencies](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/app/BUILD.bazel#L617)
+2. [deps dependencies](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/app/BUILD.bazel#L622)
+
+**[Loading an extension](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/app/BUILD.bazel#L13)**
+
+Bazel extensions are files ending in .bzl. Use the load statement to import a symbol from an extension.
+
+```
+load("@io_bazel_rules_kotlin//kotlin:android.bzl", "kt_android_library")
+```
+Here, we are loading `android.bzl` and we are going to use it with a symbol name `kt_android_library`.
+Arguments to the load function must be string literals. Load statements must appear at top-level in the file.
+
+**[Visibility of a file target](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/app/BUILD.bazel#L621)**
+
+With the example from our codebase, target `app` whose visibility is public. 
+
+ - `visibility = ["//visibility:public"],` - Anyone can use this target.
+ - `"//visibility:private"` - Only targets in this package can use this target.
+
+**[Testing](https://github.com/oppia/oppia-android/blob/7344270032ac242b1b8987f1b51c8b5aa4f14ce3/app/src/sharedTest/java/org/oppia/android/app/player/exploration/BUILD.bazel#L7)**
+
+When we want to run test cases on Bazel build environment, a test target needs to be set up correctly:
+
+```bazel
+load("//:oppia_android_test.bzl", "oppia_android_test")
+
+oppia_android_test(
+    name = "MathExpressionInteractionsViewTest",
+    srcs = [
+        "MathExpressionInteractionsViewTest.kt",
+        "//app:data_binder_mapper_impl"
+    ],
+    custom_package = "org.oppia.android.app.test",
+    test_manifest = "//app:test_manifest",
+    enable_data_binding = True,
+    test_class = "org.oppia.android.app.customview.interaction.MathExpressionInteractionsViewTest",
+    deps = [
+      ...
+    ],
+)
+```
+
+The above assumes that the corresponding test requires resources. If it doesn't, the definition can be a bit simpler:
+
+```bazel
+load("//:oppia_android_test.bzl", "oppia_android_test")
+
+oppia_android_test(
+    name = "MathExpressionAccessibilityUtilTest",
+    srcs = ["MathExpressionAccessibilityUtilTest.kt"],
+    custom_package = "org.oppia.android.app.utility.math",
+    test_manifest = "//app:test_manifest",
+    test_class = "org.oppia.android.app.utility.math.MathExpressionAccessibilityUtilTest",
+    deps = [
+      ...
+    ],
+)
+```
+
+## Syncing the Project
+The IntelliJ Bazel Plugin's Sync process has a purpose to query Bazel for information and build up IntelliJ's project structure to fit Bazel's model.
+
+It runs automatically during a project import, and manually by either clicking on the sync icon in the menu bar or, partially syncing packages and individual files in contextual menus.
+
+Running a sync generates a `.aswb` directory in the project root. 
+
+### Structure of the .aswb
+The `.aswb` is known as the **project directory**. It contains metadata about the project that bridges Bazel and IntelliJ project models.
+```
+.aswb/
+├── .bazelproject
+├── .blaze
+│   ├── aar_libraries
+│   ├── modules
+│   ├── remoteOutputCache 
+│   └── renderjars
+└── .idea
+```
+
+The `.bazelproject` is the project view file which contains project-wide settings, like targets to sync, Bazel flags, and enabled languages. It is used to import a subset of Bazel packages into the IDE. The project view determines which rules are imported and how. Read more information [here](https://ij.bazel.build/docs/project-views.html).
+
+The `.blaze` is the Bazel data subdirectory, containing mostly IntelliJ module definitions. 
+  - `modules` directory contains IntelliJ module definition files.
+  - `remoteOutputCache` is a general-purpose local cache for output artifacts generated remotely. During a project sync, updated outputs of interest will be copied locally.
+  - `aar_libraries` is the location of the plugin's JAR cache. This helps provide a more robust code navigation experience, but with the possibility of missing changes made by Bazel outside of the IDE view.
+
+The `.idea` directory contains project-specific settings files managed by IntelliJ. IntelliJ reads XML files in this directory to set up the Project Structure: project, modules, libraries, SDKs, facets.
+
+### Syncing (and Partial Syncing) the Bazel Plugin in Android Studio
+When you make certain changes to your project files, you need to sync your project with Bazel to pick up those changes. For example:
+* Changing a BUILD file, like adding a new target, or adding dependencies and sources to a target.
+* Changing generated output files required to resolve source code, like annotation processor outputs such as AutoValue-generated classes.
+
+You can sync with Bazel in two ways:
+* From your IDE’s menu, click **Bazel > Sync > Sync Project with BUILD files.**
+* From the toolbar, click the **Sync Project with BUILD files** button.
+
+**Expand Sync to Working Set**
+
+Your working set is any files your VCS says are dirty, roughly corresponding to something like git status. By default, the plugin tries to expand the sync to cover any target in your working set. This ensures these files are refreshed without having to go to the trouble of adding a temporary target to your project view.
+- This sometimes causes problems, and you may see a warning in your Bazel sync tool window to disable it.
+
+**Non-Incrementally Sync Project with BUILD Files**
+
+This option recomputes certain things that are otherwise cached. 
+- You should never have to use this option, but it exists for debugging/fallback purposes.
+
+**Sync Working Set**
+
+Your working set is any files your VCS says are dirty, roughly corresponding to something like git status. This option tries to sync only your working set, cutting down on sync time, which is useful if you want to quickly bring in new dependencies in some files you are working on.
+
+**Partially Sync File with Bazel**
+
+Syncs only the targets corresponding to the file from which this action is invoked. Can cut down on the time to sync the project if you’re only interested in resolving a single file.
+- This is invoked from the current active file.
+- It can also be accessed via right-clicking on a file and selecting the option.
+- This is useful for resolving a file marked as “(Unsynced)” or ensuring API changes are recognized by other targets.
+- This can be used on directories which is especially useful for resyncing multiple libraries or regenerating protos.
+
+**Automatic Sync**
+
+You can enable automatic syncing in **Settings > Other Settings > Bazel > Auto sync on**. Automatic syncing occurs whenever BUILD files change.
+- We do not recommend enabling this option for now, as it can be slow and disruptive. Because of performance concerns, it is disabled by default.
\ No newline at end of file
diff --git a/wiki/Contributing-to-Oppia-Android.md b/wiki/Contributing-to-Oppia-Android.md
index 2b8a32985be..d1b55ff5b34 100644
--- a/wiki/Contributing-to-Oppia-Android.md
+++ b/wiki/Contributing-to-Oppia-Android.md
@@ -12,8 +12,6 @@ If you run into any problems along the way, we're here to help! Check out our [w
 - [Onboarding instructions](#onboarding-instructions)
   - [Guidance on submitting a PR](https://github.com/oppia/oppia-android/wiki/Guidance-on-submitting-a-PR)
   - [Developing your skills](https://github.com/oppia/oppia-android/wiki/Developing-skills)
-- [Important: Ongoing Bazel migration](#important-ongoing-bazel-migration)
-- [Installing the Oppia web app](#installing-the-oppia-web-app)
 - [Communication channels](#communication-channels)
 
 ## How to find information on this wiki
@@ -49,33 +47,11 @@ When you've found an issue you'd like to tackle:
 
 - Leave a comment that describes in detail how you'll tackle it (e.g. explain which file(s) you would modify and what changes you would make), and @-mention the team lead (typically **@BenHenning**). If your explanation makes sense, we'll assign the issue to you.
 - Submit a PR, following the [guidance on submitting a PR](https://github.com/oppia/oppia-android/wiki/Guidance-on-submitting-a-PR). (Consider bookmarking this guide in your browser for easy reference. We also suggest bookmarking the ["my issues" page](https://github.com/issues/assigned) so that you can keep track of the issues assigned to you.)
-- If you run into any problems, feel free to create a [GitHub Discussion](https://github.com/oppia/oppia-android/discussions) and get help from the Oppia community.
 
 You are also welcome to tackle non-starter issues, but for those, you might need to be more independent, because we might not know how to solve them either!
 
 Once you've merged PRs that correspond to **two** different pre-existing GitHub issues, please fill in [this form](https://forms.gle/NxPjimCMqsSTNUgu5) to be considered for a place on a team at Oppia Android! A team lead will evaluate your contributions and give you access to the repository so that you can assign yourself to issues. (But please don't create your own issues and then make PRs for them -- that won't count.)
 
-
-
-## Important: Ongoing Bazel migration
-
-The team is currently using two build systems for the project: Gradle and Bazel. We're in the process of actively migrating to Bazel.
-
-Please note that:
-- It's currently recommended that all team members use **Gradle** for their active development in Android Studio. While some team members use the Bazel Android Studio plugin instead of Android Gradle Plugin (AGP), we make this recommendation because day-to-day Bazel development currently suffers from:
-  - Significant memory overhead that continues to grow without careful pruning (i.e. periodic shutdowns of the local Bazel build server). On some Linux distros, this can result in a Kernel panic when memory is fully exhausted.
-  - Various symbolic errors throughout the codebase that can make it much more difficult to jump to specific symbols (though, unlike Gradle, all code including scripts are editable and runnable within Android Studio).
-- That said, when submitting a PR for review, you may notice that some Bazel-specific tests or workflows fail. Investigating and fixing these will require setting up Bazel in your local environment (see the instructions [here](https://github.com/oppia/oppia-android/wiki/Oppia-Bazel-Setup-Instructions)), and then running the specific Bazel commands in your local repository (most team members just use the console within Android Studio to run their Bazel commands).
-- Bazel & Gradle sometimes don't play nicely with one another. So, when you're verifying Bazel-specific things, we recommend doing so in one go, and then deleting the corresponding Bazel build artifacts using ``bazel clean`` before switching back over to Gradle (to avoid any issues with the two build systems crossing). Note that Bazel generally doesn't have any problems with Gradle build artifacts, so there's no need to clean the Gradle project first.
-- As the team finishes the migration to Bazel, communications and instructions will be sent ahead of time for moving development environments away from Gradle so that we can officially deprecate it.
-
-## Installing the Oppia web app
-
-If you need to connect to a local version of the Oppia web application, check out a copy of the [Oppia web app repository](https://github.com/oppia/oppia) and get it running locally. This will allow you to connect to a local instance of the web app when developing locally.
-
-For now, you generally won't need to do this, until the Android app supports on-the-fly lesson downloading (which we're currently working on).
-
-
 ### Notes
 
 * Our central development branch is `develop`, which should be clean and ready for release at any time. All changes should be done in feature branches based off of `develop`.
@@ -102,6 +78,7 @@ For now, you generally won't need to do this, until the Android app supports on-
   ```
   By using this command git will detect the file as a renamed file.
 
+*  We don't allow force-pushing at Oppia, so once you push your commits, you can't change them. Instead, submit a new commit with the desired changes. If you find that you have force-pushed your branch, please close the PR and submit a new one in its place.
 
 ## Communication channels
 
diff --git a/wiki/End-to-End-Testing-Guide.md b/wiki/End-to-End-Testing-Guide.md
index c89cd571a66..1282eb54480 100644
--- a/wiki/End-to-End-Testing-Guide.md
+++ b/wiki/End-to-End-Testing-Guide.md
@@ -45,7 +45,7 @@ The android_binary of a test suite generates a test apk with the same name as th
 ### How to run an End-to-End test
 
 #### Prerequisites:
-1. [Set up Bazel for Oppia](https://github.com/oppia/oppia-android/wiki/Oppia-Bazel-Setup-Instructions#installation)
+1. [Set up Bazel for Oppia](https://github.com/oppia/oppia-android/wiki/Installing-Oppia-Android#install-bazel)
 2. Add adb to the environment (platform-tools) i.e, add the following line to the .bashrc or the file path (note that this is platform dependent):
     ```
     export PATH=/home/<username>/Android/Sdk/platform-tools:$PATH
diff --git a/wiki/Frequent-Errors-and-Solutions.md b/wiki/Frequent-Errors-and-Solutions.md
deleted file mode 100644
index d914c42d088..00000000000
--- a/wiki/Frequent-Errors-and-Solutions.md
+++ /dev/null
@@ -1,33 +0,0 @@
-## Table of Contents
-
-- [Dagger Unresolved reference](#dagger-unresolved-reference)
-- [Crashing layout tags in tablet](#crashing-layout-tags-in-tablet)
-- [Push failed](#push-failed)
-- [Facing error while debugging code](#facing-error-while-debugging-code)
-  - [Benefits](#benefits)
-  - [How to Write a Debugging Doc](#how-to-write-a-debugging-doc)
-
-## Dagger Unresolved reference
-**Error**: Unresolved reference `DaggerXXTest_TestApplicationComponent`
-
-**Solution**: Don't worry this is not an error. Just run the test file and it will solve the error. For running tests, you can see [Oppia Android Testing](https://github.com/oppia/oppia-android/wiki/Oppia-Android-Testing) document.
-
-## Crashing layout tags in tablet
-**Error**: java.lang.IllegalArgumentException: The tag for topic_lessons_title is invalid. Received: layout-sw600dp-port/topic_lessons_title_0
-**Solutions**: This error occurs when we remove any xml file which is related to tablet devices
-To solve this
-1. Uninstall the app from tablet
-2. Rebuild the app.
-3. Run the app again.
-
-## Push failed
-**Error**: Failed to push some refs to `git@github.com:<your_user_name>/oppia-android.git`
-
-**Solution**: If you are using Android Studio or another UI-based git to push and got the above error, this might not provide many details. Try to push using the command line. Also, we suggest using the command line, as all our scripts, project building, APK building are done using the command line as we are moving towards the Bazel build system and removing the Gradle build system. 
-
-<img src="https://i.imgur.com/0iDpCSO.png" width=400 height=250 />
-
-If there is an error with any of the lint failures it will be detailed in the command line itself. 
-
-## Facing error while debugging code
-If you are running into an error that you cannot debug, follow the guidelines outlined on this [wiki page](https://github.com/oppia/oppia-android/wiki/Debugging).
diff --git a/wiki/Gradle--Bazel-Migration-Best-Practices-and-FAQ.md b/wiki/Gradle--Bazel-Migration-Best-Practices-and-FAQ.md
index cded43f920e..f53d1fb8409 100644
--- a/wiki/Gradle--Bazel-Migration-Best-Practices-and-FAQ.md
+++ b/wiki/Gradle--Bazel-Migration-Best-Practices-and-FAQ.md
@@ -1,4 +1,4 @@
-The following document explains best practices & provides support for the Gradle to Bazel migration. For more information on setting up Bazel, read [Oppia Bazel Setup Instructions](https://github.com/oppia/oppia-android/wiki/Oppia-Bazel-Setup-Instructions).
+The following document explains best practices & provides support for the Gradle to Bazel migration. For more information on setting up Bazel, read [Oppia Bazel Setup Instructions](https://github.com/oppia/oppia-android/wiki/Installing-Oppia-Android#install-bazel).
 
 This is a living document that will grow as more questions get asked and answered.
 
diff --git a/wiki/Installing-Oppia-Android.md b/wiki/Installing-Oppia-Android.md
index dcf0a4baafb..91fbda7e0cd 100644
--- a/wiki/Installing-Oppia-Android.md
+++ b/wiki/Installing-Oppia-Android.md
@@ -5,32 +5,322 @@ This wiki page explains how to install Oppia Android on your local machine. If y
 ## Table of Contents
 
 - [Prepare developer environment](#prepare-developer-environment)
+- [Install Bazel](#install-bazel)
+  - [Bazel Set up for Mac](#bazel-set-up-for-mac)
+  - [Bazel Set up for Linux](#bazel-set-up-for-linux)
+  - [Bazel Set up for Windows](#bazel-set-up-for-windows)
 - [Install oppia-android](#install-oppia-android)
-- [Run the app from Android Studio](#run-the-app-from-android-studio)
+- [Opening the Project in Android Studio](#opening-the-project-in-android-studio)
 - [Set up and Run tests](#set-up-and-run-tests)
-  - [Step-by-Step guidance for setting up and running app modules robolectric test](#step-by-step-guidance-for-setting-up-and-running-app-modules-robolectric-test)
-  - [For tests that are in non-app modules, such as **domain** or **utility**:](#for-tests-that-are-in-non-app-modules-such-as-domain-or-utility)
-
+  - [Running app module tests](#running-app-module-tests)
+  - [Running non-app module tests](#running-non-app-module-tests)
+- [Next Steps](#next-steps)
+- [Troubleshooting Installation](#troubleshooting-installation)
 
 ## Prepare developer environment
 
-1. Download/Install [Android Studio Bumblebee | Patch 3](https://developer.android.com/studio/archive).
+1. Download and install Android Studio **Giraffe** from [this location](https://developer.android.com/studio/archive).
+   **Note**: You may try newer or older versions of Android Studio, but we can't guarantee good support as we have not tested them extensively yet.
 
-   **Note**: We recommend installing **Android Studio Bumblebee | 2021.1.1 Patch 3** because newer versions of Android Studio[ do not support running tests where shared source sets are used](https://issuetracker.google.com/issues/232007221#comment18), a configuration we use at Oppia.
+2. Configure your Android Studio
+   - From your PC's application menu, open Android Studio. 
+   - On the welcome screen, find the "more options menu" and select **SDK Manager**
+     
+     <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/efcc4e6e-b6ba-44fc-9c96-aa381de83911" />
+    
+   - In the "SDK Platforms" tab (which is the default), select `API Level 30` and also `API Level 34`.
+   - Also, navigate to the "SDK Tools" tab, click the "Show Package Details" checkbox at the bottom right, then click on "Android SDK Build-Tools 34-rc1" and select 32.0.0 (this is needed for Bazel support).
 
-   **Direct download Url**: [Windows](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-windows.exe) | [Linux](https://redirector.gvt1.com/edgedl/android/studio/ide-zips/2021.1.1.23/android-studio-2021.1.1.23-linux.tar.gz) | [Intel Mac](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-mac.dmg) | [Apple Silicon Mac](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-mac_arm.dmg)
+   - Then, click "Apply" to download and install these two SDKs/Tools.
+     - On this screen, note the **Android SDK Location**, which is set as the ANDROID_HOME variable in the Bazel setup step below.
 
-   You can have multiple versions of Android Studio installed on your machine at the same time.
+3. Prepare a test device
+   You require a physical Android device or an Android emulator to run the Oppia app. 
+   - Physical devices are useful for a real-user experience feel, and testing with [accessibility tools](https://github.com/oppia/oppia-android/wiki/Accessibility-A11y-Guide#setting-up-accessibility-scanner-and-talkback).
+   
+     **Set up a physical device for development**
+      - On the device, open the **Settings** app, select **Developer options**, and then **enable USB debugging** (if applicable).
+        - If you don't see **Developer options**, you might need to enable developer mode first. Follow [these instructions](https://developer.android.com/studio/debug/dev-options#enable) to do so.
+        - Connect to your device using USB.
+        - Verify that your device is connected by running the `adb devices` command from your terminal.
+   
+      - Emulators provide the flexibility of testing the application on a variety of devices and Android API levels without needing to have each physical device.
+   
+     **Set up an Emulator**
+      - For the best experience, you should use the emulator in Android Studio on a computer with at least the following specs:
+        - 16 GB RAM
+        - 64-bit Windows 10 or higher, MacOS 12 or higher, Linux, or ChromeOS operating system
+        - 16 GB disk space
+     
+      - If you don't have these specs, the emulator might still run but not smoothly. In this case, consider testing on a physical device.
 
-2. Configure your Android Studio
-   - In Android Studio, open Tools > SDK Manager.
-     - In the "SDK Platforms" tab (which is the default), select `API Level 28` and also `API Level 30` (for Bazel support).
-     - Also, navigate to the "SDK Tools" tab, click the "Show Package Details" checkbox at the bottom right, then click on "Android SDK Build-Tools 34-rc1" and select 32.0.0 (this is needed for Bazel support).
+      - On the welcome screen, find the "more options menu" and select **Virtual Device Manager**
+     
+        <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/efcc4e6e-b6ba-44fc-9c96-aa381de83911" />
+         
+        * If you already have a project open in Android Studio, in the right hand toolbar, locate `Device Manager`.
+      - Click the **+**, and then click **Create Virtual Device**.
+      - Follow the wizard to create a phone and a tablet AVD, setting the **system image** to be one of `API Level 30` or `API Level 34` as installed above.
+      - After creating your devices, you will be able to see a list of all the devices on the device manager panel.
+      - For more information on the different configurations available for AVDs, please visit the [official documentation page.](https://developer.android.com/studio/run/managing-avds)
 
-   - Then, click "Apply" to download and install these two SDKs/Tools.
+## Install Bazel
+### Instructions
+
+**The steps to setting up Bazel are:**
+1. Install Bazel
+2. Set Bazel and ANDROID_HOME paths permanently in your terminal
+3. Verify that the build is working
+
+The expected output of `bazel --version` once Bazel set up is successful is:
+
+```
+bazel 6.5.0
+```
+
+### Bazel Set up for Mac
+It is recommended to use the binary installer steps outlined below. For other ways to install Bazel on Mac, refer to the [official page](https://bazel.build/install/os-x).
+
+**Step 1: Install Xcode command line tools**
+
+In macOS 14 or earlier, it is sufficient to install the Xcode command line tools package by using xcode-select:
+
+```
+xcode-select --install
+```
+
+Otherwise, for macOS 15 and later, you must have Xcode 6.1 or later installed on your system.
+
+Download Xcode from the [App Store](https://apps.apple.com/us/app/xcode/id497799835) or the [Apple Developer site](https://developer.apple.com/download/more/?=xcode).
+
+Once Xcode is installed, accept the license agreement for all users with the following command:
+
+```
+sudo xcodebuild -license accept
+```
+
+**Step 2: Download the Bazel installer**
+
+Click [here](https://github.com/bazelbuild/bazel/releases/download/6.5.0/bazel-6.5.0-installer-darwin-x86_64.sh) to download the Bazel 6.5.0 binary installer.
+
+**Step 3: Run the installer**
+
+Run the Bazel installer as follows:
+
+```shell
+chmod +x "bazel-6.5.0-installer-darwin-x86_64.sh"
+./bazel-6.5.0-installer-darwin-x86_64.sh --user
+```
+
+**Step 4: Set up your environment**
+
+You must set the path for `Bazel` and `ANDROID_HOME` before running bazel build for oppia-android, otherwise you will get an error.
+
+If you ran the Bazel installer with the `--user` flag as above, the Bazel executable is installed in your $HOME/bin directory. It’s a good idea to add this directory to your default paths, as follows:
+
+```shell
+export PATH="$PATH:$HOME/bin"
+```
+
+To set the `ANDROID_HOME` path permanently in your terminal run these commands:
+
+```
+sudo nano /etc/paths
+```
+- Enter your password, when prompted.
+- Go to the bottom of the file, and enter this path: `$HOME/Library/Android/sdk`
+- Hit control-x to quit.
+- Enter “Y” to save the modified buffer.
+- That’s it! To test it, in a new terminal window, type: `echo $PATH`
+
+**Step 5: Verify that the build is working**
+
+Run the following command in your terminal:
+
+```
+bazel --version
+```
+
+### Bazel Set up for Linux
+This section covers Bazel installation on Ubuntu. 
+
+Recommendations:
+- use Ubuntu 18.04 (LTS), 20.04 (LTS), or 22.04 (LTS).
+- use ``apt`` installation instructions.
+
+- **Note**: if you encounter any errors related to `cURL`, please set up cURL on your machine using `sudo apt install curl`.
+
+**Step 1: Add Bazel distribution URI as a package source**
+
+This is a one-time setup step.
+
+```
+sudo apt install apt-transport-https curl gnupg -y
+curl -fsSL https://bazel.build/bazel-release.pub.gpg | gpg --dearmor >bazel-archive-keyring.gpg
+sudo mv bazel-archive-keyring.gpg /usr/share/keyrings
+echo "deb [arch=amd64 signed-by=/usr/share/keyrings/bazel-archive-keyring.gpg] https://storage.googleapis.com/bazel-apt stable jdk1.8" | sudo tee /etc/apt/sources.list.d/bazel.list
+```
+
+**Step 2: Install and update Bazel**
+
+Run:
+```shell
+sudo apt-get update && sudo apt-get install bazel-6.5.0
+```
+
+**Step 3: Set up your environment**
+
+Ensure that your `ANDROID_HOME` environment variable is set to the location of your Android SDK. Assuming the SDK is installed to default locations, you can use the following commands to set the `ANDROID_HOME` variable:
+
+```
+export ANDROID_HOME=$HOME/Android/Sdk/
+```
+
+**Step 4: Verify that the build is working**
+
+Run the following command in your terminal:
+
+```
+bazel --version
+```
+
+### Bazel Set up for Windows
+This page outlines one way to allow Bazel to be used in CLI form on Windows. Please note that **this support is currently experimental**. We suggest that you post a discussion at [github-discussions](https://github.com/oppia/oppia-android/discussions/categories/q-a-installation) if you run into any problems.
+
+Unlike Unix-based systems where Bazel runs natively without issue, the current solution on Windows is to install an Ubuntu-based subsystem. Windows currently only supports a terminal experience in this subsystem (though there is a prerelease version of the software with GUI support) which means Android Studio will not be supported. You will need to continue using the Windows version of Android Studio and only use the Linux subsystem for building & running Robolectric or JUnit-based tests.
+
+Due to the issues mentioned above, we recommend dual-booting your PC with Linux for a smoother experience. However, if you prefer to use Windows, please follow the instructions below:
+
+**Main prerequisites**:
+- Windows 10+: These instructions are geared towards users of Windows 10+ (older versions will not be compatible). If you're using an older version of Windows, please follow up with a comment on [this issue](https://github.com/oppia/oppia-android/issues/3371).
+- At least 4GB of free local disk storage space (for Linux & needed dependencies), but more will probably help when building the app
+
+At a high-level, the steps to make Bazel work on Windows are:
+1. Install the Ubuntu subsystem
+2. Install prerequisite debian packages
+3. Install the Android SDK
+4. Install Bazel
+5. Set up the environment to be able to build Oppia Android
+6. Verify that the build is working
+7. Run Bazel commands as needed during development
+
+**Step 1: Install Ubuntu subsystem**
+
+Please follow Microsoft's [setup instructions](https://docs.microsoft.com/en-us/windows/wsl/install-win10) to set up the Linux subsystem on Windows 10+. From there, you should install **Ubuntu** (the instructions below are based on the apt package manager on Ubuntu; other Linux distributions & package managers may work but they are untested by the team).
+
+Once installed, open the Ubuntu terminal from the start menu.
+
+From within the Ubuntu terminal, start by ensuring all packages are up-to-date:
+
+```sh
+sudo apt update && sudo apt upgrade
+```
+
+**Step 2: Install JDK 17+**
 
-   - Must have **JDK 11** selected:
-     - In Android Studio, open Settings > Build, Execution, Deployment > Build Tools > Gradle and edit the Gradle JDK field.
+Setting up Bazel for Oppia Android requires JDK>=17 for [Android Package Manager](#3-installing-the-android-sdk).
+
+For Ubuntu systems, this can be set up using:
+
+```shell
+sudo apt install openjdk-17-jdk
+```
+
+For Fedora 25+, this can be set up using:
+
+```
+sudo dnf install java-17-openjdk
+```
+
+**Step 3: Install GCC**
+
+Install gcc using the following command:
+
+```shell
+sudo apt install gcc
+```
+
+**Step 4: Install the Android SDK**
+
+We need to be able to run Linux-compatible Android utilities which requires installing a Linux version of the Android SDK. Since we can't install Android Studio in the subsystem, we need to do this via CLI commands. The steps below are extracted from [this article](https://proandroiddev.com/how-to-setup-android-sdk-without-android-studio-6d60d0f2812a).
+
+First, prepare the environment for the SDK by creating the default directory to hold the SDK (from within Ubuntu terminal):
+
+```sh
+mkdir -p $HOME/Android/Sdk
+```
+
+Second, navigate to https://developer.android.com/studio#command-tools in a web browser (in Windows) and select to download the latest **Linux** command tools (even though you're using Windows, the Linux commandline tools are needed--the Windows version will not work with these instructions). Once downloaded, copy the zip file to the new SDK location (note that the ``/mnt/c/...`` path is based on ``C:\Users\<Name>\Downloads`` being the default download location--this may not be the case on your system) with your Windows username filled in for ``<Name>``:
+
+```sh
+cp /mnt/c/Users/<Name>/Downloads/commandlinetools*.zip $HOME/Android/Sdk
+```
+
+After that, change to the directory, unzip the archive, and remove it:
+
+```sh
+cd $HOME/Android/Sdk
+unzip commandlinetools*.zip
+rm commandlinetools*.zip
+```
+
+From there, the command line tools need to be moved in order to indicate to the tools themselves that they're relative to the Android SDK root directory:
+
+```sh
+cd cmdline-tools/
+mkdir tools
+mv -i * tools
+cd ..
+```
+
+(The above may give a warning for the ``mv`` command since it will try moving ``tools`` into ``tools``--this can be ignored).
+
+At this point, we can define the ``ANDROID_HOME`` variable to point to the new SDK root, and also update the ``PATH`` to point to cmdnline-tools so that we can actually install the SDK. To do this, run the following commands to append new lines to ``~/.bashrc``:
+
+```sh
+echo "export ANDROID_HOME=\$HOME/Android/Sdk" >> ~/.bashrc
+echo "export PATH=\$ANDROID_HOME/cmdline-tools/tools/bin/:\$PATH" >> ~/.bashrc
+source ~/.bashrc
+```
+
+(The last line reloads your Bash configuration file so that the variable adjustments above become live in your local terminal).
+
+The ``sdkmanager`` command can now be used to install the necessary packages. Run each of the following commands in succession (you may need to accept licenses for the SDK packages in the same way you would when using Android Studio):
+
+```sh
+sdkmanager
+sdkmanager --install "platform-tools"
+sdkmanager --install "platforms;android-33"
+sdkmanager --install "build-tools;32.0.0"
+```
+
+When the commands above are finished running, the Android SDK should now be installed in your subsystem & be accessible to Bazel.
+
+**Step 5: Install Bazel**
+
+Use the steps outlined for Ubuntu Linux [above](#bazel-set-up-for-linux).
+
+For Fedora 25+
+- Install Bazelisk instead of Bazel using the command below in Fedora:
+```
+wget https://github.com/bazelbuild/bazelisk/releases/download/v1.8.1/bazelisk-linux-amd64
+chmod +x bazelisk-linux-amd64
+sudo mv bazelisk-linux-amd64 /usr/local/bin/bazel
+```
+
+**Step 6: Verify that the build is working**
+
+Run the following command in your terminal:
+
+```
+bazel --version
+```
+
+**Known limitations with using an Ubuntu subsystem on Windows:**
+- Android Studio must run on native Windows: this is a current limitation. However, https://github.com/microsoft/wslg is a WIP project that may provide an alternative option which allows full development to take place within the subsystem.
+- The subsystem is very slow: unfortunately, this is just a limitation with how the subsystem works on Windows. Until we fix the actual build pipeline to work natively, this is likely going to be a limitation that we have to live with. Note that installing an Ubuntu VM or dual-booting Ubuntu may lead to less issues & better performance than using a subsystem, but this hasn't yet been investigated or documented yet (see [#3437](https://github.com/oppia/oppia-android/issues/3437) for the WIP issue).
+- ADB is limited within the subsystem and thus must be used from within a Windows CLI like Command Prompt, Powershell, or Git Bash (if it's installed) in order to deploy the Bazel-built test or APK binary to an emulator or real device
+- Emulators likely cannot be launched from the subsystem (headless might be possible, but this hasn't been tested)
 
 ## Install oppia-android
 
@@ -40,20 +330,17 @@ Please follow these steps to set up Oppia Android on your local machine.
 
    **Note**: Please keep the folder name as `oppia-android`. Changing the project folder name might lead to future issues with running the pre-push checks on your machine.
 
-2. Run the `bash scripts/setup.sh` script, which adds some development tools for Oppia Android (ktlint, checkstyle, etc.): These tools perform pre-push checks to ensure that your code is properly formatted as per Oppia standards.
+2. Run the `bash scripts/setup.sh` script, which adds some development tools for Oppia Android (ktlint, checkstyle, etc.). You should see a message indicating that the various tools have been downloaded.
 
-    - For Mac or Linux
+   ![image](https://github.com/user-attachments/assets/d039f070-a842-4874-b534-01df39599ce6)  
+   
+   **Note** These tools perform important pre-push checks to ensure that your code is properly formatted as per Oppia standards.
+
+    - **For Mac or Linux**
        1. Open a terminal and navigate to `opensource/oppia-android/`.
        2. Run the script `bash scripts/setup.sh`.
 
-    - For Mac with Apple M1 chip
-       1. Locate Terminal in Finder.
-       2. Right-click and create a duplicate Terminal (and rename it accordingly, say Terminal x86, to avoid confusion).
-       3. In the Terminal x86, right-click and click "Get info", and check the option "Open using Rosetta".
-       4. Navigate to `opensource/oppia-android/` in Rosetta.
-       5. Finally, run `bash scripts/setup.sh` in Terminal x86 and all the required files should be generated. (You should see messages like `Ktlint file downloaded`, etc.)
-
-    - For Windows
+    - **For Windows**
        1. Install [Git Bash Command Line](https://gitforwindows.org/)
 
           **Note**: When installing Git bash, check the option to add it to powershell, so that you can run bash commands from within powershell.
@@ -63,85 +350,99 @@ Please follow these steps to set up Oppia Android on your local machine.
        5. Download the [google_checks.xml](https://github.com/checkstyle/checkstyle/blob/14005e371803bd52dff429904b354dc3e72638c0/src/main/resources/google_checks.xml) file. To do this, you can simply right-click on the download button at the top-right of the file.
        6. Copy this file to the directory where Git is installed (usually C:/Program Files/Git/).
 
-3. In Android Studio, select `File > Open`, navigate to `opensource/oppia-android/`, and click `OK` to load the project.
+## Opening the project in Android Studio
 
-4. Select the Compile JDK version
-   - Go to Android Studio > Settings > Build, Execution, Deployment > Build Tools > Gradle
-   - Under "**Gradle JDK**", select Android Studio Default JDK 11.
-   - Then, click "Apply" and "OK" to complete your setup.
-5. Click the elephant icon in the toolbar ("Sync Gradle") to ensure that all the correct dependencies are downloaded. (In general, you'll want to do this step any time you update your dependencies.)
+1. Launch Android Studio, and on the welcome screen, select **Plugins** to install the Bazel for Android Studio plugin and restart Android Studio.
 
-## Run the app from Android Studio
+2. On next open, click the options button next to the new project/open project to find the "Import Bazel Project" option.
 
-1. Go to Tools > AVD Manager, click "Create Virtual Device...". Then:
+   <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/efcc4e6e-b6ba-44fc-9c96-aa381de83911" />
 
-   - Select a preferred device definition. In general, any device is fine, but you can use Pixel 3a as a default (if you're developing for phones) or Nexus 7 (if you're developing for tablets). After selecting a device, click "Next" at the bottom right to continue.
-   - Select a system image (in general, API Level 28, unless you're an M1 Mac user, in which case use API Level 29). Then click "Next".
-   - Click "Finish" to complete setup.
+3. A setup wizard will open. For Workspace, click (**...**) to open file manager and select `/opensource/oppia-android` as the location since this is where we have our project's `WORKSPACE` file.
 
-2. To run the app, select the emulator device you want from the dropdown menu to the left of the "Run" button in the toolbar.
+   ![Image](https://github.com/user-attachments/assets/9baf6f71-560b-49fe-84a7-c7b846a64287)
 
-3. Finally, click the "Run" button.
+4. On **OK**, you will be asked to **Trust project**. Accept because we trust the project.
 
-## Set up and run tests
-Testing the app is an integral part of our development process. You will need to test all code changes to ensure that the app works correctly, therefore it is important to ensure that your test configuration works.
+   <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/bfc91f6d-d809-418d-ab20-89d899f12f72" />
+
+5. On **next**, to Select Project View, select **Import project view file**.
+
+   <img width="991" alt="Screenshot 2025-03-19 at 18 44 41" src="https://github.com/user-attachments/assets/2679a750-414b-4680-8558-7f438e11f633" />
+
+Click on the 3 dots to open the file picker. Scroll down and select `oppia-android.bazelproject`, then click **next**.
 
-We strongly recommend running tests on Robolectric which is faster because it does not require a physical device or emulator setup.
+   <img width="991" alt="Screenshot 2025-03-19 at 18 45 23" src="https://github.com/user-attachments/assets/31e0694c-a179-4adf-8d4d-28793c586ee5" />
 
-### Configure Robolectric Tests
+6. The project view will be generated as follows. Click the **Create** button to complete the import.
 
-#### Step-by-Step guidance for setting up and running app modules robolectric test:
+   ![Screenshot 2025-03-19 at 18 47 57](https://github.com/user-attachments/assets/b7016ab8-9ae5-44e0-a624-c7cc8fc576da)
 
-1. Go to **Edit Configuration** in Android Studio (Bumblebee | 2021.1.1 Patch 3)
-   ![](https://user-images.githubusercontent.com/9396084/79109714-83525980-7d96-11ea-99d7-f83ea81a8a50.png)
+7. Immediately, the project will begin to synchronize, and will be ready once sync completes. Read more about syncing in the [Bazel User Guide](https://github.com/oppia/oppia-android/wiki/Bazel-User-Guide#Syncing-the-project).
 
-2. Click on Add(+) -> **JUnit**
-   ![](https://github.com/oppia/oppia-android/assets/76530270/87caf3fc-37d9-472d-92fd-b8ec49fb6b49)
+   ![Screenshot 2025-03-19 at 18 49 59](https://github.com/user-attachments/assets/603d85d6-1336-4893-8153-eef8caef5e81)
 
-3. Enter following information:
-   - a) Name of test. Example: In my case "SplashActivityTest"
-   - b) Make sure select "java 11" and oppia-android.app
-   - c) Class path of Test class. Example: In my case "org.oppia.android.app.splash.
-   SplashActivityTest"
-   - d) Press `OK` to select the test.
-   ![](https://github.com/oppia/oppia-android/assets/76530270/5901624a-df76-4b27-8f31-6077a68fcb89)
+**Note**: Unlike Gradle, Bazel does not support the "**Android**" project view. To see all project directories, switch to the "**Project**" view instead.
 
-4. Click on "Run" button to run robolectric test. (In my case "SplashActivityTest")
-   ![](https://github.com/oppia/oppia-android/assets/76530270/75a6b998-90c5-4f0a-8886-78f96970be90)
+In the `.aswb` directory, you will find the generated `.bazelproject` file. It should contain:
 
-#### For tests that are in non-app modules, such as **domain** or **utility**::
+```shell
+import oppia-android.bazelproject
+```
 
-1. In Android Studio, open the desired test file, e.g., `AnalyticsControllerTest`.
-2. In the test file, to the left of the class name, click on the orange and green arrow, and select **Run 'AnalyticsControllerTest'**.
-   - You will notice that the emulator is greyed out, but the run window will open to show the running tests:
-   ![](https://user-images.githubusercontent.com/59600948/272657015-158117e5-47d2-40fc-a38b-5dee6c347556.png)
+8. Once sync has finished, you can now build and install the app on either a virtual or physical device. Bazel supports deploying to only one device at a time, so you can connect one device, or launch one emulator at a time.
 
-### Configure Emulator Tests
+   You can run the project by using the Bazel plugin to set up run configurations for the target that you wish to build. This performs the same action as the run commands listed in the [Bazel user guide](https://github.com/oppia/oppia-android/wiki/Bazel-User-Guide), but using the GUI to run the app might be more intuitive for some developers.
 
-**Espresso is slower for running tests, so we recommend using Robolectric.**
+   ![Screenshot 2025-02-26 at 22 16 32](https://github.com/user-attachments/assets/f3be5288-dc96-4079-bcb2-b514de81f899)
 
-1. In Android Studio, open the desired test file, e.g., `HomeActivityTest`.
-2. In the Android Studio toolbar, click on the `Available Devices` option. Select an emulator that has between API 28-30.
+   Edit configurations allows us to specify the run command:
 
-   **Note**: If you don't have any available devices in this list, please follow [these instructions](#run-the-app-from-android-studio) to create one.
+   ![Image](https://github.com/user-attachments/assets/7270b6b3-11ac-4b49-a39a-734e0437bb9e)
 
-3. In the test file, to the left of the class name, click on the orange and green arrow, and select **Run 'HomeActivityTest'**.
-   ![](https://user-images.githubusercontent.com/59600948/272657131-96e5354b-13a9-4709-969a-b9494a65c30f.png)
+     - Target **Name**, is helpful for identifying the target from the list on the left.
+     - **Target expression** requires a build target such as `//:oppia_dev_binary`.
+     - **The Bazel command** is `mobile-install`
+     - **Bazel flags** are optional.
+     - Select **Apply** and then **Close** or **Ok**.
+
+## Set up and run tests
+Testing the app is an integral part of our development process. You will need to test all code changes to ensure that the app works correctly, therefore it is important to ensure that your test configuration works.
 
-4. An "**Edit Configuration**" dialog will show up, and you should add the following settings under the general tab:
-   - For module, select **oppia-android.app**
-   - For Test, select **Class**
-   - For Instrumentation class, **org.oppia.android.testing.OppiaTestRunner**, will be selected by default.
-   - For target, select the **Use the device/snapshot dropdown** option.
-   - Verify that your setup looks like below:
+Our Bazel setup currently supports running tests on Robolectric which is fast because it does not require a physical device or emulator setup.
 
-     ![](https://user-images.githubusercontent.com/59600948/272657260-2e654891-61be-467a-8ebd-c997aa2abda6.png)
-- Finally, Click the "Apply" and "Okay" buttons.
-- You may need to repeat step (3) above to run the test with the new configuration.
-- Subsequent runs of any app module tests will not require editing the configuration.
-- This configuration will run all the tests in that class.
-5. To run only a specific test in a file:
-   - Search or scroll down to the desired test name, to the left of the test name, click on the run icon and select **Run '`test name`''**.
+We can run tests either through the UI supported by the Bazel Plugin, or via running a `bazel test` command on the terminal.
+
+Please refer to the [Bazel User Guide](https://github.com/oppia/oppia-android/wiki/Bazel-User-Guide) for more information on how to run tests via the terminal.
+
+### Running app module tests
+
+1. In Android Studio, open the test file that you wish to run. If sync completed successfully when the project was opened, there will be a green run arrow next to the class name, as well as next to each individual test name. Clicking on the arrow will run either the full class or a single test as selected.
+
+2. Because we have set up the Bazel plugin, we can also run a test class using the run arrow at the top of the project window:
+
+   ![Screenshot 2025-02-26 at 22 16 32](https://github.com/user-attachments/assets/f3be5288-dc96-4079-bcb2-b514de81f899)
+
+   Edit configurations allows us to specify the run command:
+   ![Screenshot 2025-02-26 at 22 19 34](https://github.com/user-attachments/assets/462d07d2-4407-4898-bbc4-544509bd7486)
+
+   - Test **name** is helpful for identifying the test target from the list on the left.
+   - **Target expression** requires the fully qualified path to the test file.
+   - **The Bazel command** for running tests is `test`
+   - **Bazel flags** are optional.
+   - Select **Apply** and then **Close** or **Ok**.
+
+### Running non-app module tests
+
+These are tests in other modules, such as **domain** or **utility**.
+
+1. In Android Studio, open the test file that you wish to run. If sync completed successfully when the project was opened, there will be a green run arrow next to the class name, as well as next to each individual test name. Clicking on the arrow will run either the full class or a single test as selected.
+   
+   ![Screenshot 2025-03-18 at 21 35 11](https://github.com/user-attachments/assets/4f83c8d2-cbb9-49cb-ac3b-3e500e1f82f6)
+
+2. A second way to run a test class would be to open the `BUILD` file located in the same package as the test file, and clicking on the green arrow next to the test target name.
+  
+   ![Image](https://github.com/user-attachments/assets/c1ee9e23-b0b2-430a-9592-9f87a2fdcbf0)
 
 ### Next Steps
 - Congratulations, you are ready to work on your first issue! Take a look at our [good first issues](https://github.com/oppia/oppia-android/issues?q=is%3Aopen+is%3Aissue+label%3A%22good+first+issue%22+no%3Aassignee) and leave a comment with your suggested fix. A maintainer will assign you the issue and provide any necessary guidance.
@@ -150,8 +451,105 @@ We strongly recommend running tests on Robolectric which is faster because it do
 
 - To learn about how we write tests at oppia-android, please refer to: [Oppia Android Testing](https://github.com/oppia/oppia-android/wiki/Oppia-Android-Testing).
 
-- To get started with Bazel, please see [Oppia-Bazel-Setup-Instructions](https://github.com/oppia/oppia-android/wiki/Oppia-Bazel-Setup-Instructions) and follow the instructions appropriate to your OS.
-
-- If you run into any issues during your setup, search our [discussions](https://github.com/oppia/oppia-android/discussions) forum or start a new discussion.
-
-- Please see  [Troubleshooting-Installation](https://github.com/oppia/oppia-android/wiki/Troubleshooting-Installation) for solutions to some common setup issues.
+- An important reference to go back to as you continue developing with Bazel is the [Bazel User Guide](https://github.com/oppia/oppia-android/wiki/Bazel-User-Guide).
+
+### Troubleshooting Installation
+#### General issues
+1. If the Static Checks on your PR keep failing, please refer to [instructions on running static checks locally](https://github.com/oppia/oppia-android/wiki/Static-Analysis-Checks#how-to-run-static-checks-locally) in order to catch these errors before pushing.
+2. If you are using Android Studio or another UI-based git to push, you might see unclear errors such as `Error: Failed to push some refs to git@github.com:<your_user_name>/oppia-android.git`. We recommend using the command line to run all git commands.
+3. **Error**: Unresolved reference `DaggerXXTest_TestApplicationComponent`. **Solution**: Don't worry this is not an error. Just run the test file and it will solve the error. For running tests, you can see [Oppia Android Testing](https://github.com/oppia/oppia-android/wiki/Oppia-Android-Testing) document.
+4. Crashing layout tags in tablet, e.g.:
+   **Error**: `java.lang.IllegalArgumentException: The tag for topic_lessons_title is invalid. Received: layout-sw600dp-port/topic_lessons_title_0`
+   **Solution**: This error occurs when we remove any xml file which is related to tablet devices
+   To solve this
+      - Uninstall the app from tablet
+      - Rebuild the app.
+      - Run the app again.
+
+#### Bazel issues
+The team is in the process of migrating away from Gradle to Bazel, so while the project still has Gradle build files, they are no longer maintained and cannot be used to build the project.
+
+Please note that:
+- The IntelliJ Bazel plugin currently has some known issues:
+    - Significant memory overhead that continues to grow without careful pruning (i.e. periodic shutdowns of the local Bazel build server). On some Linux distros or MacOS, this can result in a Kernel panic when memory is fully exhausted.
+    - Various symbolic errors throughout the codebase that can make it much more difficult to jump to specific symbols (though, unlike Gradle, all code including scripts are editable and runnable within Android Studio).
+    - Syntax highlighting errors in some instances.
+- As the team finishes the migration to Bazel, communications and instructions will be sent ahead of time, and we will continually update our documentation with the latest changes.
+
+Other problems that you may run into:
+
+1. No matching toolchains (sdk_toolchain_type)
+    ```
+    ERROR: While resolving toolchains for target //:oppia_dev: no matching toolchains found for types
+    @bazel_tools//tools/android:sdk_toolchain_type
+    ERROR: Analysis of target '//:oppia_dev' failed; build aborted: no matching toolchains found for types
+    @bazel_tools//tools/android:sdk_toolchain_type
+    INFO: Elapsed time: 12.805s
+    INFO: 0 processes.
+    FAILED: Build did NOT complete successfully (13 packages loaded, 51 targets configured)
+    ```
+   Follow the [steps](https://docs.bazel.build/versions/main/tutorial/android-app.html#integrate-with-the-android-sdk) to add the ANDROID_HOME environment variable.
+
+2. java.lang.ClassNotFoundException: com.android.tools.r8.compatdx.CompatDx
+   If, when building the app binary, you encounter a failure that indicates that the `CompatDx` file cannot be found, this is likely due to you using a newer version of the Android build tools. You can manually downgrade to an older version of build-tools (particularly 32.0.0). Unfortunately, this can't be done through Android Studio but it can be done over a terminal. Follow the instructions listed [here](https://github.com/oppia/oppia-android/issues/3024#issuecomment-884513455) to downgrade your build tools & then try to build the app again.
+
+3. If you encounter this error while building bazel on Apple Silicone Mac:
+      ```
+      ERROR: /Users/OpenSource/oppia-android/model/src/main/proto/BUILD.bazel:167:20: Generating JavaLite proto_library //model/src/main/proto:profile_proto failed: (Segmentation fault): protoc failed: error executing command bazel-out/darwin-opt-exec-2B5CBBC6/bin/external/com_google_protobuf/protoc '--proto_path=bazel-out/android-armeabi-v7a-fastbuild/bin/model/src/main/proto/_virtual_imports/languages_proto' ... (remaining 8 argument(s) skipped)
+
+      Use --sandbox_debug to see verbose messages from the sandbox protoc failed: error executing command bazel-out/darwin-opt-exec-2B5CBBC6/bin/external/com_google_protobuf/protoc '--proto_path=bazel-out/android-armeabi-v7a-fastbuild/bin/model/src/main/proto/_virtual_imports/languages_proto' ... (remaining 8 argument(s) skipped)
+      ```
+    Bazel requires Xcode commandline tools to build on M1, and the Xcode license also needs to be accepted.
+    
+    **Follow these steps to solve this error:**
+    
+    - Install the commandline tools: `xcode-select --install`
+    
+    - Accept the Xcode licence: `sudo xcodebuild -licence`
+    
+    - Reset the xcode select path: `sudo xcode-select -r `
+    
+    - Set the xcode select path to use CommandLineTools: `sudo xcode-select -s /Library/Developer/CommandLineTools`
+        Note: As of macOS 15.2.1(Sequoia), the full Xcode is required rather than just the CLT. The xcode-select path needs to point to Xcode instead:
+        `sudo xcode-select -s /Applications/Xcode.app/Contents/Developer`
+    
+    - Confirm that the path was correctly set. The expected output is: `/Library/Developer/CommandLineTools` or `/Applications/Xcode.app/Contents/Developer` in macOS 15 and later.
+    
+        `xcode-select -p`
+    
+    After successfully running the above commands, build the app using Bazel by running the following command:
+
+      ```
+      bazel clean --expunge
+      bazel build //:oppia_dev
+      ```
+4. If you run into a failure like the following when trying to use `mobile-install` to a device running SDK 30 or newer:
+
+    ```
+    FATAL EXCEPTION: main
+    Process: org.oppia.android, PID: 9508
+    java.lang.RuntimeException: Unable to instantiate application com.google.devtools.build.android.incrementaldeployment.StubApplication package org.oppia.android: java.lang.SecurityException: Writable dex file '/data/local/tmp/incrementaldeployment/org.oppia.android/dex/incremental_classes4.dex' is not allowed.
+    at android.app.LoadedApk.makeApplicationInner(LoadedApk.java:1466)
+    at android.app.LoadedApk.makeApplicationInner(LoadedApk.java:1395)
+    at android.app.ActivityThread.handleBindApplication(ActivityThread.java:6959)
+    at android.app.ActivityThread.-$$Nest$mhandleBindApplication(Unknown Source:0)
+    at android.app.ActivityThread$H.handleMessage(ActivityThread.java:2236)
+    at android.os.Handler.dispatchMessage(Handler.java:106)
+    at android.os.Looper.loopOnce(Looper.java:205)
+    at android.os.Looper.loop(Looper.java:294)
+    at android.app.ActivityThread.main(ActivityThread.java:8177)
+    at java.lang.reflect.Method.invoke(Native Method)
+    at com.android.internal.os.RuntimeInit$MethodAndArgsCaller.run(RuntimeInit.java:552)
+    at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:971)
+    Caused by: java.lang.SecurityException: Writable dex file '/data/local/tmp/incrementaldeployment/org.oppia.android/dex/incremental_classes4.dex' is not allowed.
+    ```
+    
+    Then you will need to use `adb install` directly:
+    
+    ```shell
+    adb install bazel-bin/oppia_dev_binary.apk
+    ```
+
+### Can’t find a particular issue?
+
+If the error you get is not in the Troubleshooting section above, please post a request for help on the team's discussions board for installation problems: https://github.com/oppia/oppia-android/discussions/categories/q-a-installation.
\ No newline at end of file
diff --git a/wiki/Oppia-Android-Code-Coverage.md b/wiki/Oppia-Android-Code-Coverage.md
index 0d294887e8f..b82d170c884 100644
--- a/wiki/Oppia-Android-Code-Coverage.md
+++ b/wiki/Oppia-Android-Code-Coverage.md
@@ -298,7 +298,7 @@ With this report, you can review the coverage percentages for various files and
 
 While the CI check provides an overview of coverage, you might want to visualize how tests cover specific files locally, including which lines are covered and which are not. For this, Oppia's local command-line coverage tooling is useful.
 
-Note: Follow these [Bazel setup instructions](https://github.com/oppia/oppia-android/wiki/Oppia-Bazel-Setup-Instructions) if Bazel isn't yet set up in your local development environment.
+Note: Follow these [Bazel setup instructions](https://github.com/oppia/oppia-android/wiki/Installing-Oppia-Android) if Bazel isn't yet set up in your local development environment.
 
 Oppia Android allows you to generate coverage reports in HTML format using the command:
 
diff --git a/wiki/Oppia-Bazel-Setup-Instructions.md b/wiki/Oppia-Bazel-Setup-Instructions.md
deleted file mode 100644
index 65083228e76..00000000000
--- a/wiki/Oppia-Bazel-Setup-Instructions.md
+++ /dev/null
@@ -1,135 +0,0 @@
-## Table of Contents
-
-- [Overview](#overview)
-- [Installation](#installation)
-  - [Building the app](#building-the-app)
-  - [Building + installing the app](#building--installing-the-app)
-  - [Running specific module (app) Robolectric tests](#running-specific-module-app-robolectric-tests)
-  - [Running all Robolectric tests (slow)](#running-all-robolectric-tests-slow)
-- [Known Issues and Troubleshooting](#known-issues-and-troubleshooting)
-- [Concepts and Terminology](#concepts-and-terminology)
-
-## Overview
-Bazel is an open-source build and test tool similar to Make, Maven, and Gradle. It uses a human-readable, high-level build language.
-
-**WARNING: We recommend to not use the Android Studio Bazel plugin since it currently has compatibility issues with the project.**
-
-### Installation
-
-1. Download and Install Java 11 using the links from the [Java website](https://www.java.com/en/download/).
-
-2. **Select your Operating System for instructions on setting up Bazel:**
-
-   - [For Windows/Ubuntu/Fedora](https://github.com/oppia/oppia-android/wiki/Bazel-Setup-Instructions-for-Windows)
-   - [For Mac including M1/M2](https://github.com/oppia/oppia-android/wiki/Bazel-Setup-Instructions-for-Mac)
-   - [For Linux](https://github.com/oppia/oppia-android/wiki/Bazel-Setup-Instructions-for-Linux)
-
-### Building the app
-
-After the installation completes you can build the app using Bazel.
-
-**Move your command line head to the `~/opensource/oppia-android`**, then run the below bazel command:
-
-```
-bazel build //:oppia_dev
-```
-
-#### Building + installing the app
-
-```
-bazel run //:install_oppia_dev
-```
-
-#### Running specific module (app) Robolectric tests
-
-```
-bazel test //app/...
-```
-
-#### Running all Robolectric tests (slow)
-
-```
-bazel test //...
-```
-
-## Known Issues and Troubleshooting
-
-See our [troubleshooting wiki page](https://github.com/oppia/oppia-android/wiki/Troubleshooting-Installation#bazel-issues) for some known issues with Bazel, and the corresponding troubleshooting steps.
-
-
-## Concepts and Terminology
-**[Workspace](https://github.com/oppia/oppia-android/blob/develop/WORKSPACE)**<br>
-A workspace is a directory where we add targeted SDK version, all the required dependencies and there required Rules. The directory containing the WORKSPACE file is the root of the main repository, which in our case is the `oppia-android` root directory is the main directory.
-
-**[Packages](https://github.com/oppia/oppia-android/tree/develop/app)**<br>
-A package is defined as a directory containing a file named BUILD or BUILD.bazel.
-
-**[Binary rules](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/BUILD.bazel#L3)**<br>
-A rule specifies the relationship between inputs and outputs, and the steps to build the outputs.
-In Android, rules are defined using `android_binary`. Android rules for testing are `android_instrumentation_test` and `android_local_test`.
-
-**[BUILD files](https://github.com/oppia/oppia-android/blob/develop/app/BUILD.bazel)**<br>
-Every package contains a BUILD file. This file is written in Starlark Language. In this Build file for module-level, we generally define `android_library`, `kt_android_library` to build our package files as per the requirement.
-
-**[Dependencies](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/BUILD.bazel#L16)**<br>
-A target A depends upon a target B if B is needed by A at build. `A -> B`<br>
-```
-deps = [ "//app",]
-```
-Here, `deps` is used to define the dependencies which is a type of dependencies called `deps dependencies` and it includes the files/directory/target which are dependent. From the above example the dependency is the `app` target which is defined in the [Build file of app package](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/app/BUILD.bazel#L616).
-
-Example of Dependencies
-1. [srcs dependencies](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/app/BUILD.bazel#L617)
-2. [deps dependencies](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/app/BUILD.bazel#L622)
-
-**[Loading an extension](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/app/BUILD.bazel#L13)**<br>
-Bazel extensions are files ending in .bzl. Use the load statement to import a symbol from an extension.<br>
-```
-load("@io_bazel_rules_kotlin//kotlin:android.bzl", "kt_android_library")
-```
-Here, we are loading `android.bzl` and we are going to use it with a symbol name `kt_android_library`.
-Arguments to the load function must be string literals. load statements must appear at top-level in the file.
-
-**[Visibility of a file target](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/app/BUILD.bazel#L621)**<br>
-With the example from our codebase, target `app` whose visibility is public. <br>
- - `visibility = ["//visibility:public"],` - Anyone can use this target.<br>
- - `"//visibility:private"` - Only targets in this package can use this target.
-
-**[Testing](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/app/BUILD.bazel#L719)**<br>
-when we want to run test cases on Bazel build environment, a test target needs to be set up correctly:
-
-```bazel
-load("//:oppia_android_test.bzl", "oppia_android_test")
-
-oppia_android_test(
-    name = "MathExpressionInteractionsViewTest",
-    srcs = [
-        "MathExpressionInteractionsViewTest.kt",
-        "//app:data_binder_mapper_impl"
-    ],
-    custom_package = "org.oppia.android.app.test",
-    test_manifest = "//app:test_manifest",
-    enable_data_binding = True,
-    test_class = "org.oppia.android.app.customview.interaction.MathExpressionInteractionsViewTest",
-    deps = [
-      ...
-    ],
-)
-```
-
-The above assumes that the corresponding test requires resources. If it doesn't, the definition can be a bit simpler:
-
-```bazel
-load("//:oppia_android_test.bzl", "oppia_android_test")
-
-oppia_android_test(
-    name = "MathExpressionAccessibilityUtilTest",
-    srcs = ["MathExpressionAccessibilityUtilTest.kt"],
-    custom_package = "org.oppia.android.app.utility.math",
-    test_class = "org.oppia.android.app.utility.math.MathExpressionAccessibilityUtilTest",
-    test_manifest = "//app:test_manifest",
-    deps = [
-      ...
-    ],
-)
-```
diff --git a/wiki/Static-Analysis-Checks.md b/wiki/Static-Analysis-Checks.md
index 6cfd8b2e022..a3f2e492437 100644
--- a/wiki/Static-Analysis-Checks.md
+++ b/wiki/Static-Analysis-Checks.md
@@ -264,7 +264,7 @@ To fix failing tests from GitHub CI individually, follow the steps below.
 - Alternatively, in Android Studio, go to the `.github` folder and find the [static_checks.yml](https://github.com/oppia/oppia-android/blob/develop/.github/workflows/static_checks.yml) file. Search for the line that corresponds to the name of the job that failed. You can then run the same script on your local terminal.
 - You can also go to scripts/static_checks.sh to view the failing check and run it locally.
 
-Note: Before running the script command in your local terminal, make sure you have Bazel installed. To learn how to set up Bazel for Oppia Android, follow these [instructions](https://github.com/oppia/oppia-android/wiki/Oppia-Bazel-Setup-Instructions). Also make sure you have oppia-android-tools installed since static checks rely on these tools to be able to perform some of the checks. To install oppia-android-tools, run `bash scripts/setup.sh` in the oppia-android directory.
+Note: Before running the script command in your local terminal, make sure you have Bazel installed. To learn how to set up Bazel for Oppia Android, follow these [instructions](https://github.com/oppia/oppia-android/wiki/Installing-Oppia-Android#install-bazel). Also, make sure you have `oppia-android-tools` installed since static checks rely on these tools to be able to perform some of the checks. To install oppia-android-tools, run `bash scripts/setup.sh` in the oppia-android directory.
 
 ### Developer Video - Understanding CI check failures
 Learn how to interpret and troubleshoot oppia-android CI check failures in this insightful [developer video](https://youtu.be/HLzHQULZbJE?si=RLY9_8Yzv5cjYM7q).
\ No newline at end of file
diff --git a/wiki/Troubleshooting-Installation.md b/wiki/Troubleshooting-Installation.md
deleted file mode 100644
index 2ae7f5fe449..00000000000
--- a/wiki/Troubleshooting-Installation.md
+++ /dev/null
@@ -1,128 +0,0 @@
-Here are some general troubleshooting tips for oppia-android. The specific platforms are Linux, Windows and Mac OS.
-
-## Table of Contents
-
-- [General issues](#general-issues)
-- [Bazel issues](#bazel-issues)
-- [Can’t find a particular issue?](#cant-find-a-particular-issue)
-
-### General issues
-
-1. If you find any error related to `cURL`, please set up cURL on your machine. For Linux, you can use `sudo apt install curl`. No need to set up `cURL` for Windows as you are using git bash command line.<br>
-
-
-2. If you find any error which says `java: command not found`, please check you have Java installed correctly in your machine and the [environment path variable](https://www.java.com/en/download/help/path.html) is also set up correctly.
-
-
-3. If you find any error related to Kotlin or Java/Checkstyle while pushing the code, please check [this link](https://github.com/oppia/oppia-android/wiki/Frequent-Errors-and-Solutions#push-failed).
-
-
-4. If you see the error
-
-   ```
-   Could not resolve protoc-3.8.0-osx-aarch_64.exe (`com.google.protobuf:protoc:3.8.0`)
-   ```
-
-   then please follow the 2nd step mentioned in [this wiki](https://github.com/oppia/oppia-android/wiki/Installing-Oppia-Android#install-oppia-android) for Mac with Apple silicon(M1/M2) chips.
-
-
-5. If you see the error
-
-   ```
-   Deprecated Gradle features were used in this build, making it incompatible with Gradle 7.0.
-   ```
-
-   then it's fine to ignore it. The message just appears to be a warning. We don't use Gradle 7.0, so this warning is fine to ignore.
-
-6. If you see the error
-
-   ```
-   Error `Class 'org.oppia.android.app.profile.PinPasswordActivityTest' not found in module 'oppia-android.app'`
-   ```
-
-   or `Module not specified` while running Unit Tests, try to downgrade Android Studio to [Bumblebee (Patch 3)](https://developer.android.com/studio/archive). That should resolve this issue.
-
-
-7. If you encounter this error while building gradle:
-
-   ```
-   > Task :utility:kaptGenerateStubsDebugKotlin FAILED
-   Execution failed for task ':utility:kaptGenerateStubsDebugKotlin'.
-   > Could not resolve all files for configuration ':utility:debugCompileClasspath'.
-      > Failed to transform model.jar (project :model) to match attributes {artifactType=android-classes, org.gradle.category=library, org.gradle.dependency.bundling=external, org.gradle.jvm.version=15, org.gradle.libraryelements=jar, org.gradle.usage=java-api}.
-         > Execution failed for JetifyTransform: E:\Android\open-source\oppia-android\model\build\libs\model.jar.
-            > Failed to transform 'E:\Android\open-source\oppia-android\model\build\libs\model.jar' using Jetifier. Reason: Unsupported class file major version 59. (Run with --stacktrace for more details.)
-   ```
-   You are seeing this because Oppia android currently compiles with Java 8, or 9. Higher versions of Java are not supported by our version of Gradle.
-
-   The `model.jar` was compiled with Java 15/major version 59, hence the incompatibility.
-
-
-   To fix this error, you need to lower the version of Java to compile the JAR file. Please see [here](https://developer.android.com/studio/intro/studio-config#jdk) for more information about Java versions.
-
-### Bazel issues
-
-1. No matching toolchains (sdk_toolchain_type)
-    ```
-    ERROR: While resolving toolchains for target //:oppia_dev: no matching toolchains found for types
-    @bazel_tools//tools/android:sdk_toolchain_type
-    ERROR: Analysis of target '//:oppia_dev' failed; build aborted: no matching toolchains found for types
-    @bazel_tools//tools/android:sdk_toolchain_type
-    INFO: Elapsed time: 12.805s
-    INFO: 0 processes.
-    FAILED: Build did NOT complete successfully (13 packages loaded, 51 targets configured)
-    ```
-    [Steps](https://docs.bazel.build/versions/main/tutorial/android-app.html#integrate-with-the-android-sdk) to add ANDROID_HOME environment variable.
-
-
-2. If you encounter the following:
-   ```
-      external/bazel_tools/src/tools/android/java/com/google/devtools/build/android/dexer/DexFileSplitter.java:21: error: package com.android.dex does not exist
-   import com.android.dex.DexFormat;
-                         ^
-   ```
-
-   This means that you're still configured for using the custom Oppia Android tool repository for Bazel 4.x (which is no longer needed with Bazel 6.x+). You can fix this by updating your ~/.bazelrc file and either commenting out (e.g. by adding a ``#`` at the start of the line), or removing, the following line:
-
-   ```
-   build --override_repository=android_tools=/home/user/opensource/oppia-bazel-tools
-   ```
-
-3. **java.lang.ClassNotFoundException: com.android.tools.r8.compatdx.CompatDx**
-
-   If, when building the app binary, you encounter a failure that indicates that the CompatDx file cannot be found, this is likely due to you using a newer version of the Android build tools. You can manually downgrade to an older version of build-tools (particularly 32.0.0). Unfortunately, this can't be done through Android Studio but it can be done over a terminal. Follow the instructions listed [here](https://github.com/oppia/oppia-android/issues/3024#issuecomment-884513455) to downgrade your build tools & then try to build the app again.
-
-
-4. If you encounter this error while building bazel in Mac M1:
-      ```
-      ERROR: /Users/OpenSource/oppia-android/model/src/main/proto/BUILD.bazel:167:20: Generating JavaLite proto_library //model/src/main/proto:profile_proto failed: (Segmentation fault): protoc failed: error executing command bazel-out/darwin-opt-exec-2B5CBBC6/bin/external/com_google_protobuf/protoc '--proto_path=bazel-out/android-armeabi-v7a-fastbuild/bin/model/src/main/proto/_virtual_imports/languages_proto' ... (remaining 8 argument(s) skipped)
-
-      Use --sandbox_debug to see verbose messages from the sandbox protoc failed: error executing command bazel-out/darwin-opt-exec-2B5CBBC6/bin/external/com_google_protobuf/protoc '--proto_path=bazel-out/android-armeabi-v7a-fastbuild/bin/model/src/main/proto/_virtual_imports/languages_proto' ... (remaining 8 argument(s) skipped)
-      ```
-Bazel requires Xcode commandline tools to build on M1, and the Xcode license also needs to be accepted.
-
-   **Follow these steps to solve this error:**
-
-- Install the commandline tools: `xcode-select --install`
-
-- Accept the Xcode licence: `sudo xcodebuild -licence`
-
-- Reset the xcode select path: `sudo xcode-select -r `
-
- - Set the xcode select path to use CommandLineTools: `sudo xcode-select -s /Library/Developer/CommandLineTools`
-
-- Confirm that the path was correctly set. The expected output is: `/Library/Developer/CommandLineTools`
-
-      xcode-select -p
-
-After successfully running the above commands, build the app using Bazel by running the following command:
-
-      ```
-      bazel clean --expunge
-      bazel build //:oppia_dev --noexperimental_check_desugar_deps
-      ```
-The `--noexperimental_check_desugar_deps` flag is explained in the [bazel blog](https://blog.bazel.build/2018/12/19/bazel-0.21.html#android).
-
-### Can’t find a particular issue?
-
-If the error you get is not in the Troubleshooting section above, please post a request for help on the team's discussions board for installation problems: https://github.com/oppia/oppia-android/discussions/categories/q-a-installation.
diff --git a/wiki/Upgrading-Target-Sdk-Guide.md b/wiki/Upgrading-Target-Sdk-Guide.md
index bc5ce02e032..d66015812b4 100644
--- a/wiki/Upgrading-Target-Sdk-Guide.md
+++ b/wiki/Upgrading-Target-Sdk-Guide.md
@@ -64,7 +64,7 @@ The new comment should include an explicit indication of whether the audit was c
 ### Step 3: Testing the app & filing problems
 
 Compatibility with the new target SDK should be done by:
-1. Building a local production [Bazel build](https://github.com/oppia/oppia-android/wiki/Oppia-Bazel-Setup-Instructions#building-the-app) of the app (``//:oppia_beta``) and deployed to a local emulator or device running the **same** version of Android as the new target SDK version.
+1. Building a local production [Bazel build](https://github.com/oppia/oppia-android/wiki/Installing-Oppia-Android#install-bazel) of the app (``//:oppia_beta``) and deployed to a local emulator or device running the **same** version of Android as the new target SDK version.
     - Note that this requires the local app's target SDK to be temporarily upgraded (see step (5) below) but not checked in.
     - In some cases, a real device may need to be used instead of an emulator since certain features change behavior on an emulator (such as the drag and drop interaction).
     - If the app isn't already using the new version of Android as its compile SDK version, then it may fail to build. Any build failures should be filed as issues on the issue tracker and fixed before this step of the process can continue.
diff --git a/wiki/_Sidebar.md b/wiki/_Sidebar.md
index c6639f04b52..0569e7677e5 100644
--- a/wiki/_Sidebar.md
+++ b/wiki/_Sidebar.md
@@ -10,14 +10,8 @@
   * Contributing to Oppia Android
     * [Getting Started](https://github.com/oppia/oppia-android/wiki/Contributing-to-Oppia-Android)
     * [Installing Oppia-Android](https://github.com/oppia/oppia-android/wiki/Installing-Oppia-Android)
-    * [Troubleshooting Installation](https://github.com/oppia/oppia-android/wiki/Troubleshooting-Installation)
     * [How to Get Help ]( https://github.com/oppia/oppia-android/wiki/Get-Help)
     * [Overview of the Oppia Android codebase and architecture](https://github.com/oppia/oppia-android/wiki/Overview-of-the-Oppia-Android-codebase-and-architecture)
-  * Bazel
-    * [Bazel setup instructions](https://github.com/oppia/oppia-android/wiki/Oppia-Bazel-Setup-Instructions)
-      * [Bazel Setup Instructions for Linux](https://github.com/oppia/oppia-android/wiki/Bazel-Setup-Instructions-for-Linux)
-      * [Bazel Setup Instructions for Mac](https://github.com/oppia/oppia-android/wiki/Bazel-Setup-Instructions-for-Mac)
-      * [Bazel Setup Instructions for Windows](https://github.com/oppia/oppia-android/wiki/Bazel-Setup-Instructions-for-Windows)
   * Key Workflows
     * [Guidance on submitting a PR](https://github.com/oppia/oppia-android/wiki/Guidance-on-submitting-a-PR)
     * [Creating a screenshot](https://github.com/oppia/oppia-android/wiki/Creating-a-screenshot)
@@ -57,6 +51,7 @@
   * [Spotlight Guide](https://github.com/oppia/oppia-android/wiki/Spotlight-Guide)
   * [Triaging Process](https://github.com/oppia/oppia-android/wiki/Triaging-process)
   * Bazel
+    * [Exploring Bazel](https://github.com/oppia/oppia-android/wiki/Bazel-User-Guide)
     * [Gradle Bazel Migration Best Practices and FAQ](https://github.com/oppia/oppia-android/wiki/Gradle--Bazel-Migration-Best-Practices-and-FAQ)
     * [Updating Maven Dependencies](https://github.com/oppia/oppia-android/wiki/Updating-Maven-Dependencies)
   * [Internationalization](https://github.com/oppia/oppia-android/wiki/Internationalization)


Reviews:
user: login: manas-yu
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-03-02T17:19:18Z
user: login: manas-yu
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-03-02T17:19:22Z
user: login: manas-yu
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-03-02T17:19:26Z
user: login: manas-yu
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-03-02T17:19:46Z
user: login: manas-yu
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-03-02T17:19:50Z
user: login: manas-yu
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-03-02T17:20:01Z
user: login: manas-yu
body: Hi @adhiamboperes, PTAL. I’ve left some inline comments with my initial thoughts while reviewing the documentation. The changes look clear and well-structured, and I didn’t notice any grammatical errors.
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-03-02T17:23:41Z
user: login: adhiamboperes
body: Thanks @manas-yu! I have addressed all your comments.
 
@BenHenning, 
> * Revamp the installation page to cover both app install & Bazel setup instructions. Any platform-specific stuff should be added as subsections there (but keep common stuff together so we don't need to update copies of information).

Done

> * Consolidate installation issues to the installation page rather than having a separate one.

Done, and deleted previous  issues page.

> * Move known Bazel issues to the installation issues list from the contributing page.

Done.

> * Remove the contributing page's sections on Bazel migration and installing the Oppia web app (we don't need the latter).

Done

> * Please make sure there aren't references to the old installation pages anywhere in code or the wiki pages. It'd be nice to do a redirect, but as far as I can tell that's not possible for wiki pages.

I have have done the cleanup.

> WDYT?

Generally, this is a great idea. Reducing the need to navigate back and forth has always been a goal -- we started this in https://github.com/oppia/oppia-android/issues/5099.
 
@BenHenning, PTAL. 


state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-03-13T21:43:15Z
user: login: BenHenning
state: COMMENTED
author_association: MEMBER
submitted_at: 2025-03-13T23:57:01Z
user: login: BenHenning
body: Thanks so much @adhiamboperes! This is a really nice move toward consolidating and simplifying setup and onboarding.

I have a lot of comments, but the majority are aiming at reducing potential confusion pathways and encourage further simplification and/or consolidation. PTAL.
state: CHANGES_REQUESTED
author_association: MEMBER
submitted_at: 2025-03-14T00:35:04Z
user: login: adhiamboperes
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-03-14T09:14:32Z
user: login: adhiamboperes
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-03-14T09:18:41Z
user: login: adhiamboperes
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-03-14T09:22:16Z
user: login: adhiamboperes
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-03-14T09:23:28Z
user: login: adhiamboperes
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-03-14T09:28:55Z
user: login: adhiamboperes
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-03-14T09:40:29Z
user: login: adhiamboperes
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-03-14T09:40:39Z
user: login: adhiamboperes
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-03-14T09:46:35Z
user: login: adhiamboperes
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-03-14T09:54:09Z
user: login: adhiamboperes
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-03-14T10:00:10Z
user: login: adhiamboperes
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-03-14T10:02:49Z
user: login: adhiamboperes
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-03-14T10:03:42Z
user: login: adhiamboperes
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-03-14T10:08:11Z
user: login: adhiamboperes
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-03-14T10:09:01Z
user: login: adhiamboperes
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-03-14T10:10:57Z
user: login: adhiamboperes
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-03-14T10:12:18Z
user: login: adhiamboperes
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-03-14T10:13:00Z
user: login: adhiamboperes
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-03-14T10:27:49Z
user: login: adhiamboperes
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-03-14T10:29:24Z
user: login: adhiamboperes
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-03-14T10:37:06Z
user: login: adhiamboperes
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-03-14T10:40:31Z
user: login: adhiamboperes
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-03-14T10:41:19Z
user: login: adhiamboperes
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-03-14T10:57:18Z
user: login: adhiamboperes
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-03-14T10:59:14Z
user: login: adhiamboperes
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-03-14T11:00:28Z
user: login: adhiamboperes
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-03-14T11:01:03Z
user: login: adhiamboperes
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-03-14T11:09:56Z
user: login: adhiamboperes
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-03-14T11:11:00Z
user: login: adhiamboperes
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-03-14T11:16:39Z
user: login: manas-yu
body: Thanks @adhiamboperes PTAL. The changes look good to me—just wanted to highlight a few things.
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-03-14T20:32:17Z
user: login: adhiamboperes
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-03-18T18:15:59Z
user: login: adhiamboperes
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-03-18T18:38:23Z
user: login: adhiamboperes
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-03-18T18:38:40Z
user: login: adhiamboperes
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-03-18T20:14:30Z
user: login: adhiamboperes
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-03-18T20:16:09Z
user: login: BenHenning
body: Thanks @adhiamboperes. This looks really good!! I have very few concerns, just some small nits and content updates.

It'd be good to get some others' thoughts here beyond mine and @manas-yu. Perhaps @TanishMoral11 and @JishnuGoyal may have some thoughts (per the CLaM meeting this week).
state: COMMENTED
author_association: MEMBER
submitted_at: 2025-03-18T23:45:27Z
user: login: adhiamboperes
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-03-19T14:54:13Z
user: login: adhiamboperes
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-03-19T14:56:34Z
user: login: adhiamboperes
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-03-19T14:57:10Z
user: login: adhiamboperes
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-03-19T15:06:55Z
user: login: adhiamboperes
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-03-19T15:11:36Z
user: login: adhiamboperes
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-03-19T15:14:31Z
user: login: adhiamboperes
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-03-19T15:14:55Z
user: login: adhiamboperes
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-03-19T15:17:17Z
user: login: adhiamboperes
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-03-19T15:25:00Z
user: login: adhiamboperes
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-03-19T15:27:59Z
user: login: adhiamboperes
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-03-19T16:12:44Z
user: login: BenHenning
body: Thanks @adhiamboperes! Just two follow-ups, PTAL.
state: COMMENTED
author_association: MEMBER
submitted_at: 2025-03-19T22:00:03Z
user: login: adhiamboperes
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-03-19T22:20:59Z
user: login: adhiamboperes
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-03-20T22:42:41Z
user: login: BenHenning
body: Thanks @adhiamboperes! Really excellent changes and simplifications here. I think we can go ahead and merge this when you're ready, but feel free to get some others' thoughts first. I think it may be better just to check this in, though, and adjust once more issues are brought up.
state: APPROVED
author_association: MEMBER
submitted_at: 2025-03-25T23:59:56Z
user: login: subhajitxyz
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-03-26T13:25:49Z
user: login: subhajitxyz
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-03-26T13:29:34Z
user: login: subhajitxyz
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-03-26T13:30:37Z
user: login: subhajitxyz
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-03-26T13:36:34Z
user: login: subhajitxyz
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-03-26T13:51:39Z
user: login: subhajitxyz
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-03-26T13:59:40Z
user: login: subhajitxyz
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-03-26T14:07:03Z
user: login: subhajitxyz
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-03-26T14:10:11Z
user: login: subhajitxyz
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-03-26T14:13:25Z
user: login: theayushyadav11
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-03-26T14:23:31Z
user: login: theayushyadav11
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-03-26T14:30:16Z
user: login: TanishMoral11
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-03-26T18:08:51Z
user: login: adhiamboperes
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-03-26T22:43:55Z
user: login: adhiamboperes
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-03-26T22:44:26Z
user: login: adhiamboperes
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-03-26T22:46:01Z
user: login: adhiamboperes
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-03-26T22:47:00Z
user: login: adhiamboperes
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-03-26T22:47:20Z
user: login: adhiamboperes
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-03-26T22:48:08Z
user: login: adhiamboperes
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-03-26T22:48:49Z
user: login: adhiamboperes
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-03-26T22:51:26Z
user: login: adhiamboperes
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-03-26T22:52:28Z
user: login: adhiamboperes
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-03-26T22:53:09Z
user: login: adhiamboperes
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-03-26T22:54:09Z
user: login: adhiamboperes
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-03-26T22:56:20Z
user: login: adhiamboperes
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-03-26T23:00:34Z
user: login: adhiamboperes
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-03-26T23:01:53Z
user: login: adhiamboperes
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-03-26T23:04:08Z
user: login: adhiamboperes
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-03-26T23:07:18Z

Review comments:
diff_hunk: @@ -14,23 +14,48 @@ This wiki page explains how to install Oppia Android on your local machine. If y
 
 ## Prepare developer environment
 
-1. Download/Install [Android Studio Bumblebee | Patch 3](https://developer.android.com/studio/archive).
-
-   **Note**: We recommend installing **Android Studio Bumblebee | 2021.1.1 Patch 3** because newer versions of Android Studio[ do not support running tests where shared source sets are used](https://issuetracker.google.com/issues/232007221#comment18), a configuration we use at Oppia.
-
-   **Direct download Url**: [Windows](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-windows.exe) | [Linux](https://redirector.gvt1.com/edgedl/android/studio/ide-zips/2021.1.1.23/android-studio-2021.1.1.23-linux.tar.gz) | [Intel Mac](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-mac.dmg) | [Apple Silicon Mac](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-mac_arm.dmg)
-
-   You can have multiple versions of Android Studio installed on your machine at the same time.
+1. Download/Install the latest version of Android Studio from [this location](https://developer.android.com/studio).
 
 2. Configure your Android Studio
-   - In Android Studio, open Tools > SDK Manager.
-     - In the "SDK Platforms" tab (which is the default), select `API Level 28` and also `API Level 30` (for Bazel support).
+   - In Android Studio, open **Tools** > **SDK Manager**.
+     - In the "SDK Platforms" tab (which is the default), select `API Level 29` and also `API Level 30`.
      - Also, navigate to the "SDK Tools" tab, click the "Show Package Details" checkbox at the bottom right, then click on "Android SDK Build-Tools 34-rc1" and select 32.0.0 (this is needed for Bazel support).
 
    - Then, click "Apply" to download and install these two SDKs/Tools.
 
-   - Must have **JDK 11** selected:
-     - In Android Studio, open Settings > Build, Execution, Deployment > Build Tools > Gradle and edit the Gradle JDK field.
+3. Prepare a test device
+   You require a physical Android device or an Android emulator to run the Oppia app. 
+   - Physical devices are useful for a real-user experience feel, and testing with [accessibility tools](https://github.com/oppia/oppia-android/wiki/Accessibility-A11y-Guide#setting-up-accessibility-scanner-and-talkback).
+   
+     **Set up a physical device for development**
+      - On the device, open the **Settings** app, select **Developer options**, and then **enable USB debugging** (if applicable).
+        - If you don't see **Developer options**, you might need to enable developer mode first. Follow [these instructions](https://developer.android.com/studio/debug/dev-options#enable) to do so.
+        - Connect to your device using USB.
+        - Verify that your device is connected by running the `adb devices` command from your terminal.
+   - Emulators provide the flexibility of testing the application on a variety of devices and Android API levels without needing to have each physical device.
+   
+     **Emulator system requirements**
+       For the best experience, you should use the emulator in Android Studio on a computer with at least the following specs:
path: wiki/Installing-Oppia-Android.md
user: login: manas-yu
body: The bullet points (if that was the intended format) below are not rendered correctly due to indentation.
created_at: 2025-03-02T17:19:18Z
author_association: CONTRIBUTOR
diff_hunk: @@ -14,23 +14,48 @@ This wiki page explains how to install Oppia Android on your local machine. If y
 
 ## Prepare developer environment
 
-1. Download/Install [Android Studio Bumblebee | Patch 3](https://developer.android.com/studio/archive).
-
-   **Note**: We recommend installing **Android Studio Bumblebee | 2021.1.1 Patch 3** because newer versions of Android Studio[ do not support running tests where shared source sets are used](https://issuetracker.google.com/issues/232007221#comment18), a configuration we use at Oppia.
-
-   **Direct download Url**: [Windows](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-windows.exe) | [Linux](https://redirector.gvt1.com/edgedl/android/studio/ide-zips/2021.1.1.23/android-studio-2021.1.1.23-linux.tar.gz) | [Intel Mac](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-mac.dmg) | [Apple Silicon Mac](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-mac_arm.dmg)
-
-   You can have multiple versions of Android Studio installed on your machine at the same time.
+1. Download/Install the latest version of Android Studio from [this location](https://developer.android.com/studio).
path: wiki/Installing-Oppia-Android.md
user: login: manas-yu
body: Would it be reasonable to recommend the latest version even after encountering the syntax highlighting issue in Ladybug AS?
created_at: 2025-03-02T17:19:22Z
author_association: CONTRIBUTOR
diff_hunk: @@ -59,15 +59,14 @@ Once you've merged PRs that correspond to **two** different pre-existing GitHub
 
 ## Important: Ongoing Bazel migration
 
-The team is currently using two build systems for the project: Gradle and Bazel. We're in the process of actively migrating to Bazel.
+The team is in the process of migrating away from Gradle to Bazel, so while the project still has Gradle build files, they are no longer maintained and cannot be used to build the project.
 
 Please note that:
-- It's currently recommended that all team members use **Gradle** for their active development in Android Studio. While some team members use the Bazel Android Studio plugin instead of Android Gradle Plugin (AGP), we make this recommendation because day-to-day Bazel development currently suffers from:
-  - Significant memory overhead that continues to grow without careful pruning (i.e. periodic shutdowns of the local Bazel build server). On some Linux distros, this can result in a Kernel panic when memory is fully exhausted.
+- It's currently recommended that all team members use **Bazel** for their active development in Android Studio. While some team members use the Bazel Android Studio plugin, day-to-day Bazel development currently suffers from:
+  - Significant memory overhead that continues to grow without careful pruning (i.e. periodic shutdowns of the local Bazel build server). On some Linux distros or MacOS, this can result in a Kernel panic when memory is fully exhausted.
   - Various symbolic errors throughout the codebase that can make it much more difficult to jump to specific symbols (though, unlike Gradle, all code including scripts are editable and runnable within Android Studio).
-- That said, when submitting a PR for review, you may notice that some Bazel-specific tests or workflows fail. Investigating and fixing these will require setting up Bazel in your local environment (see the instructions [here](https://github.com/oppia/oppia-android/wiki/Oppia-Bazel-Setup-Instructions)), and then running the specific Bazel commands in your local repository (most team members just use the console within Android Studio to run their Bazel commands).
-- Bazel & Gradle sometimes don't play nicely with one another. So, when you're verifying Bazel-specific things, we recommend doing so in one go, and then deleting the corresponding Bazel build artifacts using ``bazel clean`` before switching back over to Gradle (to avoid any issues with the two build systems crossing). Note that Bazel generally doesn't have any problems with Gradle build artifacts, so there's no need to clean the Gradle project first.
-- As the team finishes the migration to Bazel, communications and instructions will be sent ahead of time for moving development environments away from Gradle so that we can officially deprecate it.
+  - Syntax highlighting errors in some instances.
path: wiki/Contributing-to-Oppia-Android.md
user: login: manas-yu
body: If needed, it be more specific to mention the actual IDE issue: "Syntax highlighting has been temporarily turned off due to an internal error."
created_at: 2025-03-02T17:19:25Z
author_association: CONTRIBUTOR
diff_hunk: @@ -63,85 +84,154 @@ Please follow these steps to set up Oppia Android on your local machine.
        5. Download the [google_checks.xml](https://github.com/checkstyle/checkstyle/blob/14005e371803bd52dff429904b354dc3e72638c0/src/main/resources/google_checks.xml) file. To do this, you can simply right-click on the download button at the top-right of the file.
        6. Copy this file to the directory where Git is installed (usually C:/Program Files/Git/).
 
-3. In Android Studio, select `File > Open`, navigate to `opensource/oppia-android/`, and click `OK` to load the project.
-
-4. Select the Compile JDK version
-   - Go to Android Studio > Settings > Build, Execution, Deployment > Build Tools > Gradle
-   - Under "**Gradle JDK**", select Android Studio Default JDK 11.
-   - Then, click "Apply" and "OK" to complete your setup.
-5. Click the elephant icon in the toolbar ("Sync Gradle") to ensure that all the correct dependencies are downloaded. (In general, you'll want to do this step any time you update your dependencies.)
-
 ## Run the app from Android Studio
 
-1. Go to Tools > AVD Manager, click "Create Virtual Device...". Then:
-
-   - Select a preferred device definition. In general, any device is fine, but you can use Pixel 3a as a default (if you're developing for phones) or Nexus 7 (if you're developing for tablets). After selecting a device, click "Next" at the bottom right to continue.
-   - Select a system image (in general, API Level 28, unless you're an M1 Mac user, in which case use API Level 29). Then click "Next".
-   - Click "Finish" to complete setup.
-
-2. To run the app, select the emulator device you want from the dropdown menu to the left of the "Run" button in the toolbar.
-
-3. Finally, click the "Run" button.
+1. Launch Android Studio, and on the welcome screen, select **Plugins** to install the Bazel for Android Studio plugin and restart Android Studio.
+
+2. On next open, click the options button next to the new project/open project to find the "Import Bazel Project" option.
+
+   <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/efcc4e6e-b6ba-44fc-9c96-aa381de83911" />
+
+3. A setup wizard will open. For Workspace, click (**...**) to open file manager and select /opensource/oppia-android as the location since this is where we have our project's `WORKSPACE` file.
path: wiki/Installing-Oppia-Android.md
user: login: manas-yu
body: ```suggestion
3. A setup wizard will open. For Workspace, click (**...**) to open file manager and select `/opensource/oppia-android` as the location since this is where we have our project's `WORKSPACE` file.
```
created_at: 2025-03-02T17:19:46Z
author_association: CONTRIBUTOR
diff_hunk: @@ -63,85 +84,154 @@ Please follow these steps to set up Oppia Android on your local machine.
        5. Download the [google_checks.xml](https://github.com/checkstyle/checkstyle/blob/14005e371803bd52dff429904b354dc3e72638c0/src/main/resources/google_checks.xml) file. To do this, you can simply right-click on the download button at the top-right of the file.
        6. Copy this file to the directory where Git is installed (usually C:/Program Files/Git/).
 
-3. In Android Studio, select `File > Open`, navigate to `opensource/oppia-android/`, and click `OK` to load the project.
-
-4. Select the Compile JDK version
-   - Go to Android Studio > Settings > Build, Execution, Deployment > Build Tools > Gradle
-   - Under "**Gradle JDK**", select Android Studio Default JDK 11.
-   - Then, click "Apply" and "OK" to complete your setup.
-5. Click the elephant icon in the toolbar ("Sync Gradle") to ensure that all the correct dependencies are downloaded. (In general, you'll want to do this step any time you update your dependencies.)
-
 ## Run the app from Android Studio
 
-1. Go to Tools > AVD Manager, click "Create Virtual Device...". Then:
-
-   - Select a preferred device definition. In general, any device is fine, but you can use Pixel 3a as a default (if you're developing for phones) or Nexus 7 (if you're developing for tablets). After selecting a device, click "Next" at the bottom right to continue.
-   - Select a system image (in general, API Level 28, unless you're an M1 Mac user, in which case use API Level 29). Then click "Next".
-   - Click "Finish" to complete setup.
-
-2. To run the app, select the emulator device you want from the dropdown menu to the left of the "Run" button in the toolbar.
-
-3. Finally, click the "Run" button.
+1. Launch Android Studio, and on the welcome screen, select **Plugins** to install the Bazel for Android Studio plugin and restart Android Studio.
+
+2. On next open, click the options button next to the new project/open project to find the "Import Bazel Project" option.
+
+   <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/efcc4e6e-b6ba-44fc-9c96-aa381de83911" />
+
+3. A setup wizard will open. For Workspace, click (**...**) to open file manager and select /opensource/oppia-android as the location since this is where we have our project's `WORKSPACE` file.
+
+   ![Image](https://github.com/user-attachments/assets/9baf6f71-560b-49fe-84a7-c7b846a64287)
+
+4. On **OK**, you will be asked to **Trust project**. Accept because we trust the project.
+
+   <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/bfc91f6d-d809-418d-ab20-89d899f12f72" />
+
+5. On **next**, to Select Project View, **select Create from scratch**.
+
+   <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/cdc110d6-2926-4f96-b7d8-117e2c716f76" />
+
+6. A file similar to the one below will be generated:
+
+   <img width="760" alt="Image" src="https://github.com/user-attachments/assets/5a26210f-865d-4048-b5a5-73379984bfb5" />
+
+7. In the above file, modify it so that it looks like below(copy and paste):
+   
+   ```
+   directories:
+      # Add the directories you want added as source here
+      # By default, we've added your entire workspace ('.')
+      .
+      
+   # Automatically includes all relevant targets under the 'directories' above
+   derive_targets_from_directories: true
path: wiki/Installing-Oppia-Android.md
user: login: manas-yu
body: In the [gist](https://gist.github.com/BenHenning/676113880e469727fe752c149da98e5b) by Ben, the property `derive_targets_from_directories` is set to `false`. I have also set it to `false` since we have already explicitly specified targets under the `targets` field below.  

setting it to true does not make much difference in the build but could lead to unexpected targets being indexed—just wanted to point it out for discussion.

created_at: 2025-03-02T17:19:50Z
author_association: CONTRIBUTOR
diff_hunk: @@ -63,85 +84,154 @@ Please follow these steps to set up Oppia Android on your local machine.
        5. Download the [google_checks.xml](https://github.com/checkstyle/checkstyle/blob/14005e371803bd52dff429904b354dc3e72638c0/src/main/resources/google_checks.xml) file. To do this, you can simply right-click on the download button at the top-right of the file.
        6. Copy this file to the directory where Git is installed (usually C:/Program Files/Git/).
 
-3. In Android Studio, select `File > Open`, navigate to `opensource/oppia-android/`, and click `OK` to load the project.
-
-4. Select the Compile JDK version
-   - Go to Android Studio > Settings > Build, Execution, Deployment > Build Tools > Gradle
-   - Under "**Gradle JDK**", select Android Studio Default JDK 11.
-   - Then, click "Apply" and "OK" to complete your setup.
-5. Click the elephant icon in the toolbar ("Sync Gradle") to ensure that all the correct dependencies are downloaded. (In general, you'll want to do this step any time you update your dependencies.)
-
 ## Run the app from Android Studio
 
-1. Go to Tools > AVD Manager, click "Create Virtual Device...". Then:
-
-   - Select a preferred device definition. In general, any device is fine, but you can use Pixel 3a as a default (if you're developing for phones) or Nexus 7 (if you're developing for tablets). After selecting a device, click "Next" at the bottom right to continue.
-   - Select a system image (in general, API Level 28, unless you're an M1 Mac user, in which case use API Level 29). Then click "Next".
-   - Click "Finish" to complete setup.
-
-2. To run the app, select the emulator device you want from the dropdown menu to the left of the "Run" button in the toolbar.
-
-3. Finally, click the "Run" button.
+1. Launch Android Studio, and on the welcome screen, select **Plugins** to install the Bazel for Android Studio plugin and restart Android Studio.
+
+2. On next open, click the options button next to the new project/open project to find the "Import Bazel Project" option.
+
+   <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/efcc4e6e-b6ba-44fc-9c96-aa381de83911" />
+
+3. A setup wizard will open. For Workspace, click (**...**) to open file manager and select /opensource/oppia-android as the location since this is where we have our project's `WORKSPACE` file.
+
+   ![Image](https://github.com/user-attachments/assets/9baf6f71-560b-49fe-84a7-c7b846a64287)
+
+4. On **OK**, you will be asked to **Trust project**. Accept because we trust the project.
+
+   <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/bfc91f6d-d809-418d-ab20-89d899f12f72" />
+
+5. On **next**, to Select Project View, **select Create from scratch**.
+
+   <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/cdc110d6-2926-4f96-b7d8-117e2c716f76" />
+
+6. A file similar to the one below will be generated:
+
+   <img width="760" alt="Image" src="https://github.com/user-attachments/assets/5a26210f-865d-4048-b5a5-73379984bfb5" />
+
+7. In the above file, modify it so that it looks like below(copy and paste):
+   
+   ```
+   directories:
+      # Add the directories you want added as source here
+      # By default, we've added your entire workspace ('.')
+      .
+      
+   # Automatically includes all relevant targets under the 'directories' above
+   derive_targets_from_directories: true
+   
+   targets:
+   # If source code isn't resolving, add additional targets that compile it here
+      //:oppia_dev_binary
+      //app
+      //app/src/main/...
+      //domain/...
+      //model/...
+      //testing/...
+      //utility/...
+      //data/...
+      //scripts/...
+      
+   additional_languages:
+      # Uncomment any additional languages you want supported
+      # c
+      # dart
+      # kotlin
+      # java
+      kotlin
+
+   # Please uncomment an android-SDK platform. Available SDKs are:
+      # android_sdk_platform: android-28
+      android_sdk_platform: android-29
+      # android_sdk_platform: android-30
+      # android_sdk_platform: android-31
+      # android_sdk_platform: android-32
+      # android_sdk_platform: android-33
+      android_sdk_platform: android-34
+   
+   shard_sync: true
+   sync_flags:
+      --local_ram_resources=HOST_RAM*.5
+      --discard_analysis_cache
+   
+   java_language_level: 11
+   ```
+   **Note**: Only enable Android-SDK platforms that you have installed per the [Prepare developer environment](#prepare-developer-environment) section above. Android-SDK platforms are useful for creating emulators to test your app with.
+
+8. Click **Create**, and allow the project to synchronize.
+
+9. Once sync has finished, you can now build and install the app on either a virtual or physical device. Bazel supports deploying to only one device at a time, so you can connect one device, or launch one emulator at a time.
+
+   Run the following commands in your terminal:
+   
+   On Sdk 29 and below, run:
+   ```
+   bazel mobile-install //:oppia_dev_binary
+   ```
+   This will build, install and launch the app on your device. 
+   
+   On Sdk 30 and newer, run:
+   ```
+   bazel build //:oppia_dev_binary
+   ```
+   followed by:
+   ```
+   adb install bazel-bin/oppia_dev_binary.apk  
+   ```
+   Starting from Sdk 30, incremental builds, like those executed using `bazel mobile-install`, are no longer permitted, necessitating the use of two separate commands.
+
+   You can also run the project by using the Bazel plugin to set up run configurations for the target that you wish to build. This performs the same action as the commands above, but using the GUI to run the app might be more intuitive for some developers.
+
+   ![Screenshot 2025-02-26 at 22 16 32](https://github.com/user-attachments/assets/f3be5288-dc96-4079-bcb2-b514de81f899)
+
+   Edit configurations allows us to specify the run command:
+
+   ![Image](https://github.com/user-attachments/assets/7270b6b3-11ac-4b49-a39a-734e0437bb9e)
+
+     - Target **Name**, is helpful for identifying the target from the list on the left.
+     - **Target expression** requires a build target such as `//:oppia_dev_binary`.
+     - **The Bazel command** is `mobile-install`
+     - **Bazel flags** are optional.
+     - Select **Apply** and then **Close** or **Ok**.
 
 ## Set up and run tests
 Testing the app is an integral part of our development process. You will need to test all code changes to ensure that the app works correctly, therefore it is important to ensure that your test configuration works.
 
-We strongly recommend running tests on Robolectric which is faster because it does not require a physical device or emulator setup.
+Our Bazel setup currently supports running tests on Robolectric which is fast because it does not require a physical device or emulator setup.
 
 ### Configure Robolectric Tests
 
-#### Step-by-Step guidance for setting up and running app modules robolectric test:
-
-1. Go to **Edit Configuration** in Android Studio (Bumblebee | 2021.1.1 Patch 3)
-   ![](https://user-images.githubusercontent.com/9396084/79109714-83525980-7d96-11ea-99d7-f83ea81a8a50.png)
+#### Step-by-Step guidance for setting up and running app module robolectric tests:
 
-2. Click on Add(+) -> **JUnit**
-   ![](https://github.com/oppia/oppia-android/assets/76530270/87caf3fc-37d9-472d-92fd-b8ec49fb6b49)
+1. In Android Studio, open the test file that you wish to run. If sync completed successfully when the project was opened, there will be a green run arrow next to the class name, as well as next to each individual test name. Clicking on the arrow will run either the full class or a single test as selected.
 
-3. Enter following information:
-   - a) Name of test. Example: In my case "SplashActivityTest"
-   - b) Make sure select "java 11" and oppia-android.app
-   - c) Class path of Test class. Example: In my case "org.oppia.android.app.splash.
-   SplashActivityTest"
-   - d) Press `OK` to select the test.
-   ![](https://github.com/oppia/oppia-android/assets/76530270/5901624a-df76-4b27-8f31-6077a68fcb89)
+2. Because we have set up the Bazel plugin, we can also run a test class using the run arrow at the top of the project window:
 
-4. Click on "Run" button to run robolectric test. (In my case "SplashActivityTest")
-   ![](https://github.com/oppia/oppia-android/assets/76530270/75a6b998-90c5-4f0a-8886-78f96970be90)
-
-#### For tests that are in non-app modules, such as **domain** or **utility**::
+   ![Screenshot 2025-02-26 at 22 16 32](https://github.com/user-attachments/assets/f3be5288-dc96-4079-bcb2-b514de81f899)
 
-1. In Android Studio, open the desired test file, e.g., `AnalyticsControllerTest`.
-2. In the test file, to the left of the class name, click on the orange and green arrow, and select **Run 'AnalyticsControllerTest'**.
-   - You will notice that the emulator is greyed out, but the run window will open to show the running tests:
-   ![](https://user-images.githubusercontent.com/59600948/272657015-158117e5-47d2-40fc-a38b-5dee6c347556.png)
+   Edit configurations allows us to specify the run command:
+   ![Screenshot 2025-02-26 at 22 19 34](https://github.com/user-attachments/assets/462d07d2-4407-4898-bbc4-544509bd7486)
 
-### Configure Emulator Tests
+   - Test **name**, is helpful for identifying the test target from the list on the left.
+   - **Target expression** requires the fully qualified path to the test file.
path: wiki/Installing-Oppia-Android.md
user: login: manas-yu
body: Would it be better to add information on how to obtain the correct qualified path for the test after making changes to the actual test file path?
created_at: 2025-03-02T17:20:01Z
author_association: CONTRIBUTOR
diff_hunk: @@ -59,15 +59,14 @@ Once you've merged PRs that correspond to **two** different pre-existing GitHub
 
 ## Important: Ongoing Bazel migration
 
-The team is currently using two build systems for the project: Gradle and Bazel. We're in the process of actively migrating to Bazel.
+The team is in the process of migrating away from Gradle to Bazel, so while the project still has Gradle build files, they are no longer maintained and cannot be used to build the project.
 
 Please note that:
-- It's currently recommended that all team members use **Gradle** for their active development in Android Studio. While some team members use the Bazel Android Studio plugin instead of Android Gradle Plugin (AGP), we make this recommendation because day-to-day Bazel development currently suffers from:
-  - Significant memory overhead that continues to grow without careful pruning (i.e. periodic shutdowns of the local Bazel build server). On some Linux distros, this can result in a Kernel panic when memory is fully exhausted.
+- It's currently recommended that all team members use **Bazel** for their active development in Android Studio. While some team members use the Bazel Android Studio plugin, day-to-day Bazel development currently suffers from:
+  - Significant memory overhead that continues to grow without careful pruning (i.e. periodic shutdowns of the local Bazel build server). On some Linux distros or MacOS, this can result in a Kernel panic when memory is fully exhausted.
   - Various symbolic errors throughout the codebase that can make it much more difficult to jump to specific symbols (though, unlike Gradle, all code including scripts are editable and runnable within Android Studio).
-- That said, when submitting a PR for review, you may notice that some Bazel-specific tests or workflows fail. Investigating and fixing these will require setting up Bazel in your local environment (see the instructions [here](https://github.com/oppia/oppia-android/wiki/Oppia-Bazel-Setup-Instructions)), and then running the specific Bazel commands in your local repository (most team members just use the console within Android Studio to run their Bazel commands).
-- Bazel & Gradle sometimes don't play nicely with one another. So, when you're verifying Bazel-specific things, we recommend doing so in one go, and then deleting the corresponding Bazel build artifacts using ``bazel clean`` before switching back over to Gradle (to avoid any issues with the two build systems crossing). Note that Bazel generally doesn't have any problems with Gradle build artifacts, so there's no need to clean the Gradle project first.
-- As the team finishes the migration to Bazel, communications and instructions will be sent ahead of time for moving development environments away from Gradle so that we can officially deprecate it.
+  - Syntax highlighting errors in some instances.
path: wiki/Contributing-to-Oppia-Android.md
user: login: adhiamboperes
body: Thanks. This wiki section has been removed in latest changes.
created_at: 2025-03-13T16:20:45Z
author_association: CONTRIBUTOR
diff_hunk: @@ -14,23 +14,48 @@ This wiki page explains how to install Oppia Android on your local machine. If y
 
 ## Prepare developer environment
 
-1. Download/Install [Android Studio Bumblebee | Patch 3](https://developer.android.com/studio/archive).
-
-   **Note**: We recommend installing **Android Studio Bumblebee | 2021.1.1 Patch 3** because newer versions of Android Studio[ do not support running tests where shared source sets are used](https://issuetracker.google.com/issues/232007221#comment18), a configuration we use at Oppia.
-
-   **Direct download Url**: [Windows](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-windows.exe) | [Linux](https://redirector.gvt1.com/edgedl/android/studio/ide-zips/2021.1.1.23/android-studio-2021.1.1.23-linux.tar.gz) | [Intel Mac](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-mac.dmg) | [Apple Silicon Mac](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-mac_arm.dmg)
-
-   You can have multiple versions of Android Studio installed on your machine at the same time.
+1. Download/Install the latest version of Android Studio from [this location](https://developer.android.com/studio).
path: wiki/Installing-Oppia-Android.md
user: login: adhiamboperes
body: I've added a note to recommend Giraffe, but we are not opposed to folks testing and reporting issues with newer versions.
created_at: 2025-03-13T16:48:52Z
author_association: CONTRIBUTOR
diff_hunk: @@ -14,23 +14,48 @@ This wiki page explains how to install Oppia Android on your local machine. If y
 
 ## Prepare developer environment
 
-1. Download/Install [Android Studio Bumblebee | Patch 3](https://developer.android.com/studio/archive).
-
-   **Note**: We recommend installing **Android Studio Bumblebee | 2021.1.1 Patch 3** because newer versions of Android Studio[ do not support running tests where shared source sets are used](https://issuetracker.google.com/issues/232007221#comment18), a configuration we use at Oppia.
-
-   **Direct download Url**: [Windows](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-windows.exe) | [Linux](https://redirector.gvt1.com/edgedl/android/studio/ide-zips/2021.1.1.23/android-studio-2021.1.1.23-linux.tar.gz) | [Intel Mac](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-mac.dmg) | [Apple Silicon Mac](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-mac_arm.dmg)
-
-   You can have multiple versions of Android Studio installed on your machine at the same time.
+1. Download/Install the latest version of Android Studio from [this location](https://developer.android.com/studio).
 
 2. Configure your Android Studio
-   - In Android Studio, open Tools > SDK Manager.
-     - In the "SDK Platforms" tab (which is the default), select `API Level 28` and also `API Level 30` (for Bazel support).
+   - In Android Studio, open **Tools** > **SDK Manager**.
+     - In the "SDK Platforms" tab (which is the default), select `API Level 29` and also `API Level 30`.
      - Also, navigate to the "SDK Tools" tab, click the "Show Package Details" checkbox at the bottom right, then click on "Android SDK Build-Tools 34-rc1" and select 32.0.0 (this is needed for Bazel support).
 
    - Then, click "Apply" to download and install these two SDKs/Tools.
 
-   - Must have **JDK 11** selected:
-     - In Android Studio, open Settings > Build, Execution, Deployment > Build Tools > Gradle and edit the Gradle JDK field.
+3. Prepare a test device
+   You require a physical Android device or an Android emulator to run the Oppia app. 
+   - Physical devices are useful for a real-user experience feel, and testing with [accessibility tools](https://github.com/oppia/oppia-android/wiki/Accessibility-A11y-Guide#setting-up-accessibility-scanner-and-talkback).
+   
+     **Set up a physical device for development**
+      - On the device, open the **Settings** app, select **Developer options**, and then **enable USB debugging** (if applicable).
+        - If you don't see **Developer options**, you might need to enable developer mode first. Follow [these instructions](https://developer.android.com/studio/debug/dev-options#enable) to do so.
+        - Connect to your device using USB.
+        - Verify that your device is connected by running the `adb devices` command from your terminal.
+   - Emulators provide the flexibility of testing the application on a variety of devices and Android API levels without needing to have each physical device.
+   
+     **Emulator system requirements**
+       For the best experience, you should use the emulator in Android Studio on a computer with at least the following specs:
path: wiki/Installing-Oppia-Android.md
user: login: adhiamboperes
body: Fixed.
created_at: 2025-03-13T16:49:07Z
author_association: CONTRIBUTOR
diff_hunk: @@ -63,85 +84,154 @@ Please follow these steps to set up Oppia Android on your local machine.
        5. Download the [google_checks.xml](https://github.com/checkstyle/checkstyle/blob/14005e371803bd52dff429904b354dc3e72638c0/src/main/resources/google_checks.xml) file. To do this, you can simply right-click on the download button at the top-right of the file.
        6. Copy this file to the directory where Git is installed (usually C:/Program Files/Git/).
 
-3. In Android Studio, select `File > Open`, navigate to `opensource/oppia-android/`, and click `OK` to load the project.
-
-4. Select the Compile JDK version
-   - Go to Android Studio > Settings > Build, Execution, Deployment > Build Tools > Gradle
-   - Under "**Gradle JDK**", select Android Studio Default JDK 11.
-   - Then, click "Apply" and "OK" to complete your setup.
-5. Click the elephant icon in the toolbar ("Sync Gradle") to ensure that all the correct dependencies are downloaded. (In general, you'll want to do this step any time you update your dependencies.)
-
 ## Run the app from Android Studio
 
-1. Go to Tools > AVD Manager, click "Create Virtual Device...". Then:
-
-   - Select a preferred device definition. In general, any device is fine, but you can use Pixel 3a as a default (if you're developing for phones) or Nexus 7 (if you're developing for tablets). After selecting a device, click "Next" at the bottom right to continue.
-   - Select a system image (in general, API Level 28, unless you're an M1 Mac user, in which case use API Level 29). Then click "Next".
-   - Click "Finish" to complete setup.
-
-2. To run the app, select the emulator device you want from the dropdown menu to the left of the "Run" button in the toolbar.
-
-3. Finally, click the "Run" button.
+1. Launch Android Studio, and on the welcome screen, select **Plugins** to install the Bazel for Android Studio plugin and restart Android Studio.
+
+2. On next open, click the options button next to the new project/open project to find the "Import Bazel Project" option.
+
+   <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/efcc4e6e-b6ba-44fc-9c96-aa381de83911" />
+
+3. A setup wizard will open. For Workspace, click (**...**) to open file manager and select /opensource/oppia-android as the location since this is where we have our project's `WORKSPACE` file.
path: wiki/Installing-Oppia-Android.md
user: login: adhiamboperes
body: Done
created_at: 2025-03-13T18:47:56Z
author_association: CONTRIBUTOR
diff_hunk: @@ -63,85 +84,154 @@ Please follow these steps to set up Oppia Android on your local machine.
        5. Download the [google_checks.xml](https://github.com/checkstyle/checkstyle/blob/14005e371803bd52dff429904b354dc3e72638c0/src/main/resources/google_checks.xml) file. To do this, you can simply right-click on the download button at the top-right of the file.
        6. Copy this file to the directory where Git is installed (usually C:/Program Files/Git/).
 
-3. In Android Studio, select `File > Open`, navigate to `opensource/oppia-android/`, and click `OK` to load the project.
-
-4. Select the Compile JDK version
-   - Go to Android Studio > Settings > Build, Execution, Deployment > Build Tools > Gradle
-   - Under "**Gradle JDK**", select Android Studio Default JDK 11.
-   - Then, click "Apply" and "OK" to complete your setup.
-5. Click the elephant icon in the toolbar ("Sync Gradle") to ensure that all the correct dependencies are downloaded. (In general, you'll want to do this step any time you update your dependencies.)
-
 ## Run the app from Android Studio
 
-1. Go to Tools > AVD Manager, click "Create Virtual Device...". Then:
-
-   - Select a preferred device definition. In general, any device is fine, but you can use Pixel 3a as a default (if you're developing for phones) or Nexus 7 (if you're developing for tablets). After selecting a device, click "Next" at the bottom right to continue.
-   - Select a system image (in general, API Level 28, unless you're an M1 Mac user, in which case use API Level 29). Then click "Next".
-   - Click "Finish" to complete setup.
-
-2. To run the app, select the emulator device you want from the dropdown menu to the left of the "Run" button in the toolbar.
-
-3. Finally, click the "Run" button.
+1. Launch Android Studio, and on the welcome screen, select **Plugins** to install the Bazel for Android Studio plugin and restart Android Studio.
+
+2. On next open, click the options button next to the new project/open project to find the "Import Bazel Project" option.
+
+   <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/efcc4e6e-b6ba-44fc-9c96-aa381de83911" />
+
+3. A setup wizard will open. For Workspace, click (**...**) to open file manager and select /opensource/oppia-android as the location since this is where we have our project's `WORKSPACE` file.
+
+   ![Image](https://github.com/user-attachments/assets/9baf6f71-560b-49fe-84a7-c7b846a64287)
+
+4. On **OK**, you will be asked to **Trust project**. Accept because we trust the project.
+
+   <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/bfc91f6d-d809-418d-ab20-89d899f12f72" />
+
+5. On **next**, to Select Project View, **select Create from scratch**.
+
+   <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/cdc110d6-2926-4f96-b7d8-117e2c716f76" />
+
+6. A file similar to the one below will be generated:
+
+   <img width="760" alt="Image" src="https://github.com/user-attachments/assets/5a26210f-865d-4048-b5a5-73379984bfb5" />
+
+7. In the above file, modify it so that it looks like below(copy and paste):
+   
+   ```
+   directories:
+      # Add the directories you want added as source here
+      # By default, we've added your entire workspace ('.')
+      .
+      
+   # Automatically includes all relevant targets under the 'directories' above
+   derive_targets_from_directories: true
path: wiki/Installing-Oppia-Android.md
user: login: adhiamboperes
body: Noted and updated
created_at: 2025-03-13T18:48:34Z
author_association: CONTRIBUTOR
diff_hunk: @@ -63,85 +84,154 @@ Please follow these steps to set up Oppia Android on your local machine.
        5. Download the [google_checks.xml](https://github.com/checkstyle/checkstyle/blob/14005e371803bd52dff429904b354dc3e72638c0/src/main/resources/google_checks.xml) file. To do this, you can simply right-click on the download button at the top-right of the file.
        6. Copy this file to the directory where Git is installed (usually C:/Program Files/Git/).
 
-3. In Android Studio, select `File > Open`, navigate to `opensource/oppia-android/`, and click `OK` to load the project.
-
-4. Select the Compile JDK version
-   - Go to Android Studio > Settings > Build, Execution, Deployment > Build Tools > Gradle
-   - Under "**Gradle JDK**", select Android Studio Default JDK 11.
-   - Then, click "Apply" and "OK" to complete your setup.
-5. Click the elephant icon in the toolbar ("Sync Gradle") to ensure that all the correct dependencies are downloaded. (In general, you'll want to do this step any time you update your dependencies.)
-
 ## Run the app from Android Studio
 
-1. Go to Tools > AVD Manager, click "Create Virtual Device...". Then:
-
-   - Select a preferred device definition. In general, any device is fine, but you can use Pixel 3a as a default (if you're developing for phones) or Nexus 7 (if you're developing for tablets). After selecting a device, click "Next" at the bottom right to continue.
-   - Select a system image (in general, API Level 28, unless you're an M1 Mac user, in which case use API Level 29). Then click "Next".
-   - Click "Finish" to complete setup.
-
-2. To run the app, select the emulator device you want from the dropdown menu to the left of the "Run" button in the toolbar.
-
-3. Finally, click the "Run" button.
+1. Launch Android Studio, and on the welcome screen, select **Plugins** to install the Bazel for Android Studio plugin and restart Android Studio.
+
+2. On next open, click the options button next to the new project/open project to find the "Import Bazel Project" option.
+
+   <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/efcc4e6e-b6ba-44fc-9c96-aa381de83911" />
+
+3. A setup wizard will open. For Workspace, click (**...**) to open file manager and select /opensource/oppia-android as the location since this is where we have our project's `WORKSPACE` file.
+
+   ![Image](https://github.com/user-attachments/assets/9baf6f71-560b-49fe-84a7-c7b846a64287)
+
+4. On **OK**, you will be asked to **Trust project**. Accept because we trust the project.
+
+   <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/bfc91f6d-d809-418d-ab20-89d899f12f72" />
+
+5. On **next**, to Select Project View, **select Create from scratch**.
+
+   <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/cdc110d6-2926-4f96-b7d8-117e2c716f76" />
+
+6. A file similar to the one below will be generated:
+
+   <img width="760" alt="Image" src="https://github.com/user-attachments/assets/5a26210f-865d-4048-b5a5-73379984bfb5" />
+
+7. In the above file, modify it so that it looks like below(copy and paste):
+   
+   ```
+   directories:
+      # Add the directories you want added as source here
+      # By default, we've added your entire workspace ('.')
+      .
+      
+   # Automatically includes all relevant targets under the 'directories' above
+   derive_targets_from_directories: true
+   
+   targets:
+   # If source code isn't resolving, add additional targets that compile it here
+      //:oppia_dev_binary
+      //app
+      //app/src/main/...
+      //domain/...
+      //model/...
+      //testing/...
+      //utility/...
+      //data/...
+      //scripts/...
+      
+   additional_languages:
+      # Uncomment any additional languages you want supported
+      # c
+      # dart
+      # kotlin
+      # java
+      kotlin
+
+   # Please uncomment an android-SDK platform. Available SDKs are:
+      # android_sdk_platform: android-28
+      android_sdk_platform: android-29
+      # android_sdk_platform: android-30
+      # android_sdk_platform: android-31
+      # android_sdk_platform: android-32
+      # android_sdk_platform: android-33
+      android_sdk_platform: android-34
+   
+   shard_sync: true
+   sync_flags:
+      --local_ram_resources=HOST_RAM*.5
+      --discard_analysis_cache
+   
+   java_language_level: 11
+   ```
+   **Note**: Only enable Android-SDK platforms that you have installed per the [Prepare developer environment](#prepare-developer-environment) section above. Android-SDK platforms are useful for creating emulators to test your app with.
+
+8. Click **Create**, and allow the project to synchronize.
+
+9. Once sync has finished, you can now build and install the app on either a virtual or physical device. Bazel supports deploying to only one device at a time, so you can connect one device, or launch one emulator at a time.
+
+   Run the following commands in your terminal:
+   
+   On Sdk 29 and below, run:
+   ```
+   bazel mobile-install //:oppia_dev_binary
+   ```
+   This will build, install and launch the app on your device. 
+   
+   On Sdk 30 and newer, run:
+   ```
+   bazel build //:oppia_dev_binary
+   ```
+   followed by:
+   ```
+   adb install bazel-bin/oppia_dev_binary.apk  
+   ```
+   Starting from Sdk 30, incremental builds, like those executed using `bazel mobile-install`, are no longer permitted, necessitating the use of two separate commands.
+
+   You can also run the project by using the Bazel plugin to set up run configurations for the target that you wish to build. This performs the same action as the commands above, but using the GUI to run the app might be more intuitive for some developers.
+
+   ![Screenshot 2025-02-26 at 22 16 32](https://github.com/user-attachments/assets/f3be5288-dc96-4079-bcb2-b514de81f899)
+
+   Edit configurations allows us to specify the run command:
+
+   ![Image](https://github.com/user-attachments/assets/7270b6b3-11ac-4b49-a39a-734e0437bb9e)
+
+     - Target **Name**, is helpful for identifying the target from the list on the left.
+     - **Target expression** requires a build target such as `//:oppia_dev_binary`.
+     - **The Bazel command** is `mobile-install`
+     - **Bazel flags** are optional.
+     - Select **Apply** and then **Close** or **Ok**.
 
 ## Set up and run tests
 Testing the app is an integral part of our development process. You will need to test all code changes to ensure that the app works correctly, therefore it is important to ensure that your test configuration works.
 
-We strongly recommend running tests on Robolectric which is faster because it does not require a physical device or emulator setup.
+Our Bazel setup currently supports running tests on Robolectric which is fast because it does not require a physical device or emulator setup.
 
 ### Configure Robolectric Tests
 
-#### Step-by-Step guidance for setting up and running app modules robolectric test:
-
-1. Go to **Edit Configuration** in Android Studio (Bumblebee | 2021.1.1 Patch 3)
-   ![](https://user-images.githubusercontent.com/9396084/79109714-83525980-7d96-11ea-99d7-f83ea81a8a50.png)
+#### Step-by-Step guidance for setting up and running app module robolectric tests:
 
-2. Click on Add(+) -> **JUnit**
-   ![](https://github.com/oppia/oppia-android/assets/76530270/87caf3fc-37d9-472d-92fd-b8ec49fb6b49)
+1. In Android Studio, open the test file that you wish to run. If sync completed successfully when the project was opened, there will be a green run arrow next to the class name, as well as next to each individual test name. Clicking on the arrow will run either the full class or a single test as selected.
 
-3. Enter following information:
-   - a) Name of test. Example: In my case "SplashActivityTest"
-   - b) Make sure select "java 11" and oppia-android.app
-   - c) Class path of Test class. Example: In my case "org.oppia.android.app.splash.
-   SplashActivityTest"
-   - d) Press `OK` to select the test.
-   ![](https://github.com/oppia/oppia-android/assets/76530270/5901624a-df76-4b27-8f31-6077a68fcb89)
+2. Because we have set up the Bazel plugin, we can also run a test class using the run arrow at the top of the project window:
 
-4. Click on "Run" button to run robolectric test. (In my case "SplashActivityTest")
-   ![](https://github.com/oppia/oppia-android/assets/76530270/75a6b998-90c5-4f0a-8886-78f96970be90)
-
-#### For tests that are in non-app modules, such as **domain** or **utility**::
+   ![Screenshot 2025-02-26 at 22 16 32](https://github.com/user-attachments/assets/f3be5288-dc96-4079-bcb2-b514de81f899)
 
-1. In Android Studio, open the desired test file, e.g., `AnalyticsControllerTest`.
-2. In the test file, to the left of the class name, click on the orange and green arrow, and select **Run 'AnalyticsControllerTest'**.
-   - You will notice that the emulator is greyed out, but the run window will open to show the running tests:
-   ![](https://user-images.githubusercontent.com/59600948/272657015-158117e5-47d2-40fc-a38b-5dee6c347556.png)
+   Edit configurations allows us to specify the run command:
+   ![Screenshot 2025-02-26 at 22 19 34](https://github.com/user-attachments/assets/462d07d2-4407-4898-bbc4-544509bd7486)
 
-### Configure Emulator Tests
+   - Test **name**, is helpful for identifying the test target from the list on the left.
+   - **Target expression** requires the fully qualified path to the test file.
path: wiki/Installing-Oppia-Android.md
user: login: adhiamboperes
body: I have added this above
created_at: 2025-03-13T19:15:14Z
author_association: CONTRIBUTOR
diff_hunk: @@ -63,85 +84,154 @@ Please follow these steps to set up Oppia Android on your local machine.
        5. Download the [google_checks.xml](https://github.com/checkstyle/checkstyle/blob/14005e371803bd52dff429904b354dc3e72638c0/src/main/resources/google_checks.xml) file. To do this, you can simply right-click on the download button at the top-right of the file.
        6. Copy this file to the directory where Git is installed (usually C:/Program Files/Git/).
 
-3. In Android Studio, select `File > Open`, navigate to `opensource/oppia-android/`, and click `OK` to load the project.
-
-4. Select the Compile JDK version
-   - Go to Android Studio > Settings > Build, Execution, Deployment > Build Tools > Gradle
-   - Under "**Gradle JDK**", select Android Studio Default JDK 11.
-   - Then, click "Apply" and "OK" to complete your setup.
-5. Click the elephant icon in the toolbar ("Sync Gradle") to ensure that all the correct dependencies are downloaded. (In general, you'll want to do this step any time you update your dependencies.)
-
 ## Run the app from Android Studio
 
-1. Go to Tools > AVD Manager, click "Create Virtual Device...". Then:
-
-   - Select a preferred device definition. In general, any device is fine, but you can use Pixel 3a as a default (if you're developing for phones) or Nexus 7 (if you're developing for tablets). After selecting a device, click "Next" at the bottom right to continue.
-   - Select a system image (in general, API Level 28, unless you're an M1 Mac user, in which case use API Level 29). Then click "Next".
-   - Click "Finish" to complete setup.
-
-2. To run the app, select the emulator device you want from the dropdown menu to the left of the "Run" button in the toolbar.
-
-3. Finally, click the "Run" button.
+1. Launch Android Studio, and on the welcome screen, select **Plugins** to install the Bazel for Android Studio plugin and restart Android Studio.
+
+2. On next open, click the options button next to the new project/open project to find the "Import Bazel Project" option.
+
+   <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/efcc4e6e-b6ba-44fc-9c96-aa381de83911" />
+
+3. A setup wizard will open. For Workspace, click (**...**) to open file manager and select /opensource/oppia-android as the location since this is where we have our project's `WORKSPACE` file.
+
+   ![Image](https://github.com/user-attachments/assets/9baf6f71-560b-49fe-84a7-c7b846a64287)
+
+4. On **OK**, you will be asked to **Trust project**. Accept because we trust the project.
+
+   <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/bfc91f6d-d809-418d-ab20-89d899f12f72" />
+
+5. On **next**, to Select Project View, **select Create from scratch**.
+
+   <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/cdc110d6-2926-4f96-b7d8-117e2c716f76" />
+
+6. A file similar to the one below will be generated:
+
+   <img width="760" alt="Image" src="https://github.com/user-attachments/assets/5a26210f-865d-4048-b5a5-73379984bfb5" />
+
+7. In the above file, modify it so that it looks like below(copy and paste):
+   
+   ```
+   directories:
+      # Add the directories you want added as source here
+      # By default, we've added your entire workspace ('.')
+      .
+      
+   # Automatically includes all relevant targets under the 'directories' above
+   derive_targets_from_directories: true
path: wiki/Installing-Oppia-Android.md
user: login: BenHenning
body: FWIW I would actually expect there to be a rather steep time and resource penalty for using derive targets unless there's some extra simplifying happening in the plugin (or if your custom targets are very extensive) since this will pull in *all* targets (including hundreds of tests). For me, it's the difference between an ~50 minute and ~100+ minute sync.
created_at: 2025-03-13T23:57:01Z
author_association: MEMBER
diff_hunk: @@ -1,128 +0,0 @@
-Here are some general troubleshooting tips for oppia-android. The specific platforms are Linux, Windows and Mac OS.
-
-## Table of Contents
-
-- [General issues](#general-issues)
-- [Bazel issues](#bazel-issues)
-- [Can’t find a particular issue?](#cant-find-a-particular-issue)
-
-### General issues
-
-1. If you find any error related to `cURL`, please set up cURL on your machine. For Linux, you can use `sudo apt install curl`. No need to set up `cURL` for Windows as you are using git bash command line.<br>
-
-
-2. If you find any error which says `java: command not found`, please check you have Java installed correctly in your machine and the [environment path variable](https://www.java.com/en/download/help/path.html) is also set up correctly.
-
-
-3. If you find any error related to Kotlin or Java/Checkstyle while pushing the code, please check [this link](https://github.com/oppia/oppia-android/wiki/Frequent-Errors-and-Solutions#push-failed).
-
-
-4. If you see the error
-
-   ```
-   Could not resolve protoc-3.8.0-osx-aarch_64.exe (`com.google.protobuf:protoc:3.8.0`)
-   ```
-
-   then please follow the 2nd step mentioned in [this wiki](https://github.com/oppia/oppia-android/wiki/Installing-Oppia-Android#install-oppia-android) for Mac with Apple silicon(M1/M2) chips.
-
-
-5. If you see the error
-
-   ```
-   Deprecated Gradle features were used in this build, making it incompatible with Gradle 7.0.
-   ```
-
-   then it's fine to ignore it. The message just appears to be a warning. We don't use Gradle 7.0, so this warning is fine to ignore.
-
-6. If you see the error
-
-   ```
-   Error `Class 'org.oppia.android.app.profile.PinPasswordActivityTest' not found in module 'oppia-android.app'`
-   ```
-
-   or `Module not specified` while running Unit Tests, try to downgrade Android Studio to [Bumblebee (Patch 3)](https://developer.android.com/studio/archive). That should resolve this issue.
-
-
-7. If you encounter this error while building gradle:
-
-   ```
-   > Task :utility:kaptGenerateStubsDebugKotlin FAILED
-   Execution failed for task ':utility:kaptGenerateStubsDebugKotlin'.
-   > Could not resolve all files for configuration ':utility:debugCompileClasspath'.
-      > Failed to transform model.jar (project :model) to match attributes {artifactType=android-classes, org.gradle.category=library, org.gradle.dependency.bundling=external, org.gradle.jvm.version=15, org.gradle.libraryelements=jar, org.gradle.usage=java-api}.
-         > Execution failed for JetifyTransform: E:\Android\open-source\oppia-android\model\build\libs\model.jar.
-            > Failed to transform 'E:\Android\open-source\oppia-android\model\build\libs\model.jar' using Jetifier. Reason: Unsupported class file major version 59. (Run with --stacktrace for more details.)
-   ```
-   You are seeing this because Oppia android currently compiles with Java 8, or 9. Higher versions of Java are not supported by our version of Gradle.
-
-   The `model.jar` was compiled with Java 15/major version 59, hence the incompatibility.
-
-
-   To fix this error, you need to lower the version of Java to compile the JAR file. Please see [here](https://developer.android.com/studio/intro/studio-config#jdk) for more information about Java versions.
-
-### Bazel issues
path: wiki/Troubleshooting-Installation.md
user: login: BenHenning
body: Are these not worth keeping in the new documentation?
created_at: 2025-03-14T00:00:50Z
author_association: MEMBER
diff_hunk: @@ -1,33 +0,0 @@
-## Table of Contents
path: wiki/Frequent-Errors-and-Solutions.md
user: login: BenHenning
body: Are these errors not worth keeping in the new documentation?
created_at: 2025-03-14T00:01:12Z
author_association: MEMBER
diff_hunk: @@ -64,7 +64,7 @@ The new comment should include an explicit indication of whether the audit was c
 ### Step 3: Testing the app & filing problems
 
 Compatibility with the new target SDK should be done by:
-1. Building a local production [Bazel build](https://github.com/oppia/oppia-android/wiki/Oppia-Bazel-Setup-Instructions#building-the-app) of the app (``//:oppia_beta``) and deployed to a local emulator or device running the **same** version of Android as the new target SDK version.
+1. Building a local production [Bazel build](https://github.com/oppia/oppia-android/wiki/Oppia-Bazel-Glossary#building-the-app) of the app (``//:oppia_beta``) and deployed to a local emulator or device running the **same** version of Android as the new target SDK version.
path: wiki/Upgrading-Target-Sdk-Guide.md
user: login: BenHenning
body: Might it be better to reference the installing documentation for this, instead?
created_at: 2025-03-14T00:03:15Z
author_association: MEMBER
diff_hunk: @@ -3,60 +3,53 @@
 - [Overview](#overview)
 - [Installation](#installation)
   - [Building the app](#building-the-app)
-  - [Building + installing the app](#building--installing-the-app)
   - [Running specific module (app) Robolectric tests](#running-specific-module-app-robolectric-tests)
   - [Running all Robolectric tests (slow)](#running-all-robolectric-tests-slow)
-- [Known Issues and Troubleshooting](#known-issues-and-troubleshooting)
 - [Concepts and Terminology](#concepts-and-terminology)
+- [Syncing the Project](#syncing-the-project)
 
 ## Overview
 Bazel is an open-source build and test tool similar to Make, Maven, and Gradle. It uses a human-readable, high-level build language.
 
 **WARNING: We recommend to not use the Android Studio Bazel plugin since it currently has compatibility issues with the project.**
 
-### Installation
+## Installation
 
-1. Download and Install Java 11 using the links from the [Java website](https://www.java.com/en/download/).
-
-2. **Select your Operating System for instructions on setting up Bazel:**
-
-   - [For Windows/Ubuntu/Fedora](https://github.com/oppia/oppia-android/wiki/Bazel-Setup-Instructions-for-Windows)
-   - [For Mac including M1/M2](https://github.com/oppia/oppia-android/wiki/Bazel-Setup-Instructions-for-Mac)
-   - [For Linux](https://github.com/oppia/oppia-android/wiki/Bazel-Setup-Instructions-for-Linux)
+Follow the instructions on the [installation page](https://github.com/oppia/oppia-android/wiki/Installing-Oppia-Android#install-bazel) to set up Bazel.
 
 ### Building the app
path: wiki/Oppia-Bazel-Glossary.md
user: login: BenHenning
body: This probably should just reference the installation page, instead (or vice versa) to avoid duplicating the mobile-install instructions and caveat.
created_at: 2025-03-14T00:04:09Z
author_association: MEMBER
diff_hunk: @@ -3,60 +3,53 @@
 - [Overview](#overview)
 - [Installation](#installation)
   - [Building the app](#building-the-app)
-  - [Building + installing the app](#building--installing-the-app)
   - [Running specific module (app) Robolectric tests](#running-specific-module-app-robolectric-tests)
   - [Running all Robolectric tests (slow)](#running-all-robolectric-tests-slow)
-- [Known Issues and Troubleshooting](#known-issues-and-troubleshooting)
 - [Concepts and Terminology](#concepts-and-terminology)
+- [Syncing the Project](#syncing-the-project)
 
 ## Overview
 Bazel is an open-source build and test tool similar to Make, Maven, and Gradle. It uses a human-readable, high-level build language.
 
 **WARNING: We recommend to not use the Android Studio Bazel plugin since it currently has compatibility issues with the project.**
 
-### Installation
+## Installation
 
-1. Download and Install Java 11 using the links from the [Java website](https://www.java.com/en/download/).
-
-2. **Select your Operating System for instructions on setting up Bazel:**
-
-   - [For Windows/Ubuntu/Fedora](https://github.com/oppia/oppia-android/wiki/Bazel-Setup-Instructions-for-Windows)
-   - [For Mac including M1/M2](https://github.com/oppia/oppia-android/wiki/Bazel-Setup-Instructions-for-Mac)
-   - [For Linux](https://github.com/oppia/oppia-android/wiki/Bazel-Setup-Instructions-for-Linux)
+Follow the instructions on the [installation page](https://github.com/oppia/oppia-android/wiki/Installing-Oppia-Android#install-bazel) to set up Bazel.
 
 ### Building the app
 
 After the installation completes you can build the app using Bazel.
 
 **Move your command line head to the `~/opensource/oppia-android`**, then run the below bazel command:
 
+On Sdk 29 and below, run:
path: wiki/Oppia-Bazel-Glossary.md
user: login: BenHenning
body: ```suggestion
On SDK 29 and below, run:
```

Nit.
created_at: 2025-03-14T00:04:14Z
author_association: MEMBER
diff_hunk: @@ -133,3 +126,59 @@ oppia_android_test(
     ],
 )
 ```
+
+## Syncing the Project
+The IntelliJ Bazel Plugin's Sync process has a purpose to query Bazel for information and build up IntelliJ's project structure to fit Bazel's model.
+
+It runs automatically during a project import, and manually by either clicking on the sync icon in the menu bar or, partially syncing packages and individual files in contextual menus.
+
+Running a sync generates a `.aswb` directory in the project root. 
+
+### Structure of the .aswb
+The `.aswb` is known as the **project directory**. It contains metadata about the project that bridges Bazel and IntelliJ project models.
+```
+.aswb/
+├── .bazelproject
+├── .blaze
+│   ├── aar_libraries
+│   ├── modules
+│   ├── remoteOutputCache 
+│   └── renderjars
+└── .idea
+```
+
+The `.bazelproject` is the project view file which contains project-wide settings, like targets to sync, Bazel flags, and enabled languages. It is used to import a subset of Bazel packages into the IDE. The project view determines which rules are imported and how. Read more information [here](https://ij.bazel.build/docs/project-views.html).
+
+The `.blaze` is the Bazel data subdirectory, containing mostly IntelliJ module definitions. 
+  - `modules` directory contains IntelliJ module definition files.
+  - `remoteOutputCache` is a general-purpose local cache for output artifacts generated remotely. During a project sync, updated outputs of interest will be copied locally.
+  - `aar_libraries` is the location of the plugin's JAR cache. This helps provide a more robust code navigation experience, but with the possibility of missing changes made by Bazel outside of the IDE view.
+
+The `.idea` directory contains project-specific settings files managed by IntelliJ. IntelliJ reads XML files in this directory to set up the Project Structure: project, modules, libraries, SDKs, facets.
+
+### Syncing (and Partial Syncing) the Bazel Plugin in Android Studio
+When you make certain changes to your project files, you need to sync your project with Bazel to pick up those changes. For example:
+* Changing a BUILD file, like adding a new target, or adding dependencies and sources to a target.
+* Changing generated output files required to resolve source code, like annotation processor outputs such as AutoValue-generated classes.
+
+You can sync with Bazel in two ways:
+* From your IDE’s menu, click **Bazel > Sync > Sync Project with BUILD files.**
+* From the toolbar, click the **Sync Project with BUILD files** button.
+
+**Expand Sync to Working Set**
+Your working set is any files your VCS says are dirty, roughly corresponding to something like git status. By default the plugin tries to expand the sync to cover any target in your working set. This ensures these files are refreshed without having to go to the trouble of adding a temporary target to your project view.
+- This sometimes causes problems, and you may see a warning in your Bazel sync tool window to disable it.
+
+**Non-Incrementally Sync Project with BUILD Files**
+This option recomputes certain things that are otherwise cached. 
+- You should never have to use this option, but exists for debugging/fallback purposes.
+
+**Sync Working Set**
+Your working set is any files your VCS says are dirty, roughly corresponding to something like git status. This option tries to sync only your working set, cutting down on sync time, which is useful if you want to quickly bring in new dependencies in some files you are working on.
+
+**Partially Sync File with Bazel**
+Syncs only the targets corresponding to the file from which this action is invoked. Can cut down on the time to sync the project if you’re only interested in resolving a single file.
+- This is invoked from the current active file.
path: wiki/Oppia-Bazel-Glossary.md
user: login: BenHenning
body: Perhaps mention as separate points that:
- This can be accessed via a right-click (for Windows/Linux).
- This is a great way to either sync a file which is currently annotated as '(Unsynced)' in the IDE or for ensuring API changes are seen by other targets.
- This can be used on directories which is especially useful for resyncing multiple libraries or regenerating protos.
created_at: 2025-03-14T00:07:09Z
author_association: MEMBER
diff_hunk: @@ -133,3 +126,59 @@ oppia_android_test(
     ],
 )
 ```
+
+## Syncing the Project
+The IntelliJ Bazel Plugin's Sync process has a purpose to query Bazel for information and build up IntelliJ's project structure to fit Bazel's model.
+
+It runs automatically during a project import, and manually by either clicking on the sync icon in the menu bar or, partially syncing packages and individual files in contextual menus.
+
+Running a sync generates a `.aswb` directory in the project root. 
+
+### Structure of the .aswb
+The `.aswb` is known as the **project directory**. It contains metadata about the project that bridges Bazel and IntelliJ project models.
+```
+.aswb/
+├── .bazelproject
+├── .blaze
+│   ├── aar_libraries
+│   ├── modules
+│   ├── remoteOutputCache 
+│   └── renderjars
+└── .idea
+```
+
+The `.bazelproject` is the project view file which contains project-wide settings, like targets to sync, Bazel flags, and enabled languages. It is used to import a subset of Bazel packages into the IDE. The project view determines which rules are imported and how. Read more information [here](https://ij.bazel.build/docs/project-views.html).
+
+The `.blaze` is the Bazel data subdirectory, containing mostly IntelliJ module definitions. 
+  - `modules` directory contains IntelliJ module definition files.
+  - `remoteOutputCache` is a general-purpose local cache for output artifacts generated remotely. During a project sync, updated outputs of interest will be copied locally.
+  - `aar_libraries` is the location of the plugin's JAR cache. This helps provide a more robust code navigation experience, but with the possibility of missing changes made by Bazel outside of the IDE view.
+
+The `.idea` directory contains project-specific settings files managed by IntelliJ. IntelliJ reads XML files in this directory to set up the Project Structure: project, modules, libraries, SDKs, facets.
+
+### Syncing (and Partial Syncing) the Bazel Plugin in Android Studio
+When you make certain changes to your project files, you need to sync your project with Bazel to pick up those changes. For example:
+* Changing a BUILD file, like adding a new target, or adding dependencies and sources to a target.
+* Changing generated output files required to resolve source code, like annotation processor outputs such as AutoValue-generated classes.
+
+You can sync with Bazel in two ways:
+* From your IDE’s menu, click **Bazel > Sync > Sync Project with BUILD files.**
+* From the toolbar, click the **Sync Project with BUILD files** button.
+
+**Expand Sync to Working Set**
+Your working set is any files your VCS says are dirty, roughly corresponding to something like git status. By default the plugin tries to expand the sync to cover any target in your working set. This ensures these files are refreshed without having to go to the trouble of adding a temporary target to your project view.
+- This sometimes causes problems, and you may see a warning in your Bazel sync tool window to disable it.
+
+**Non-Incrementally Sync Project with BUILD Files**
+This option recomputes certain things that are otherwise cached. 
+- You should never have to use this option, but exists for debugging/fallback purposes.
+
+**Sync Working Set**
+Your working set is any files your VCS says are dirty, roughly corresponding to something like git status. This option tries to sync only your working set, cutting down on sync time, which is useful if you want to quickly bring in new dependencies in some files you are working on.
+
+**Partially Sync File with Bazel**
+Syncs only the targets corresponding to the file from which this action is invoked. Can cut down on the time to sync the project if you’re only interested in resolving a single file.
+- This is invoked from the current active file.
+
+**Automatic Sync**
path: wiki/Oppia-Bazel-Glossary.md
user: login: BenHenning
body: I've never used this setting--is it too slow for us? Wondering if we should recommend against using it for now (it currently reads as "it might work, we don't know").
created_at: 2025-03-14T00:07:35Z
author_association: MEMBER
diff_hunk: @@ -3,60 +3,53 @@
 - [Overview](#overview)
 - [Installation](#installation)
   - [Building the app](#building-the-app)
-  - [Building + installing the app](#building--installing-the-app)
   - [Running specific module (app) Robolectric tests](#running-specific-module-app-robolectric-tests)
   - [Running all Robolectric tests (slow)](#running-all-robolectric-tests-slow)
-- [Known Issues and Troubleshooting](#known-issues-and-troubleshooting)
 - [Concepts and Terminology](#concepts-and-terminology)
+- [Syncing the Project](#syncing-the-project)
 
 ## Overview
 Bazel is an open-source build and test tool similar to Make, Maven, and Gradle. It uses a human-readable, high-level build language.
 
 **WARNING: We recommend to not use the Android Studio Bazel plugin since it currently has compatibility issues with the project.**
path: wiki/Oppia-Bazel-Glossary.md
user: login: BenHenning
body: Drop this warning as it's directly counter to the guidance introduced in this PR.
created_at: 2025-03-14T00:08:02Z
author_association: MEMBER
diff_hunk: @@ -3,60 +3,53 @@
 - [Overview](#overview)
path: wiki/Oppia-Bazel-Glossary.md
user: login: BenHenning
body: Perhaps this page should be 'Bazel user guide' rather than 'glossary'? It's not defining terms, it seems more for outlining "things you should know to be efficient" which feels more like a user guide. WDYT?
created_at: 2025-03-14T00:08:57Z
author_association: MEMBER
diff_hunk: @@ -5,32 +5,313 @@ This wiki page explains how to install Oppia Android on your local machine. If y
 ## Table of Contents
 
 - [Prepare developer environment](#prepare-developer-environment)
+- [install Bazel](#install-bazel)
+  - [Bazel setup for Mac](#bazel-set-up-for-mac)
+  - [Bazel setup for Linux](#bazel-set-up-for-linux)
+  - [Bazel setup for Windows](#bazel-set-up-for-windows)
 - [Install oppia-android](#install-oppia-android)
 - [Run the app from Android Studio](#run-the-app-from-android-studio)
+- [Run the app from the command line](#run-the-app-from-the-command-line)
 - [Set up and Run tests](#set-up-and-run-tests)
   - [Step-by-Step guidance for setting up and running app modules robolectric test](#step-by-step-guidance-for-setting-up-and-running-app-modules-robolectric-test)
   - [For tests that are in non-app modules, such as **domain** or **utility**:](#for-tests-that-are-in-non-app-modules-such-as-domain-or-utility)
-
+- [Next Steps](#next-steps)
+- [Troubleshooting Installation](#troubleshooting-installation)
 
 ## Prepare developer environment
 
-1. Download/Install [Android Studio Bumblebee | Patch 3](https://developer.android.com/studio/archive).
-
-   **Note**: We recommend installing **Android Studio Bumblebee | 2021.1.1 Patch 3** because newer versions of Android Studio[ do not support running tests where shared source sets are used](https://issuetracker.google.com/issues/232007221#comment18), a configuration we use at Oppia.
-
-   **Direct download Url**: [Windows](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-windows.exe) | [Linux](https://redirector.gvt1.com/edgedl/android/studio/ide-zips/2021.1.1.23/android-studio-2021.1.1.23-linux.tar.gz) | [Intel Mac](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-mac.dmg) | [Apple Silicon Mac](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-mac_arm.dmg)
-
-   You can have multiple versions of Android Studio installed on your machine at the same time.
+1. Download/Install the latest version of Android Studio from [this location](https://developer.android.com/studio).
+   **Note**: We strongly recommend **Giraffe** because it has been tested and produced the best experience across different OSes.
path: wiki/Installing-Oppia-Android.md
user: login: BenHenning
body: Suggest flipping this:

"Download and install Android Studio Giraffe from ...
**Note**: You may try newer or older versions of Android Studio, but we can't guarantee good support."

Otherwise we're forcing the reader to make a decision they may not have the context to reasonably make. Separately, we may need to link to the archive rather than the main AS page since it can be hard to find old versions.
created_at: 2025-03-14T00:10:53Z
author_association: MEMBER
diff_hunk: @@ -5,32 +5,313 @@ This wiki page explains how to install Oppia Android on your local machine. If y
 ## Table of Contents
 
 - [Prepare developer environment](#prepare-developer-environment)
+- [install Bazel](#install-bazel)
+  - [Bazel setup for Mac](#bazel-set-up-for-mac)
+  - [Bazel setup for Linux](#bazel-set-up-for-linux)
+  - [Bazel setup for Windows](#bazel-set-up-for-windows)
 - [Install oppia-android](#install-oppia-android)
 - [Run the app from Android Studio](#run-the-app-from-android-studio)
+- [Run the app from the command line](#run-the-app-from-the-command-line)
 - [Set up and Run tests](#set-up-and-run-tests)
   - [Step-by-Step guidance for setting up and running app modules robolectric test](#step-by-step-guidance-for-setting-up-and-running-app-modules-robolectric-test)
   - [For tests that are in non-app modules, such as **domain** or **utility**:](#for-tests-that-are-in-non-app-modules-such-as-domain-or-utility)
-
+- [Next Steps](#next-steps)
+- [Troubleshooting Installation](#troubleshooting-installation)
 
 ## Prepare developer environment
 
-1. Download/Install [Android Studio Bumblebee | Patch 3](https://developer.android.com/studio/archive).
-
-   **Note**: We recommend installing **Android Studio Bumblebee | 2021.1.1 Patch 3** because newer versions of Android Studio[ do not support running tests where shared source sets are used](https://issuetracker.google.com/issues/232007221#comment18), a configuration we use at Oppia.
-
-   **Direct download Url**: [Windows](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-windows.exe) | [Linux](https://redirector.gvt1.com/edgedl/android/studio/ide-zips/2021.1.1.23/android-studio-2021.1.1.23-linux.tar.gz) | [Intel Mac](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-mac.dmg) | [Apple Silicon Mac](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-mac_arm.dmg)
-
-   You can have multiple versions of Android Studio installed on your machine at the same time.
+1. Download/Install the latest version of Android Studio from [this location](https://developer.android.com/studio).
+   **Note**: We strongly recommend **Giraffe** because it has been tested and produced the best experience across different OSes.
 
 2. Configure your Android Studio
-   - In Android Studio, open Tools > SDK Manager.
-     - In the "SDK Platforms" tab (which is the default), select `API Level 28` and also `API Level 30` (for Bazel support).
+   - In Android Studio, open **Tools** > **SDK Manager**.
+     - In the "SDK Platforms" tab (which is the default), select `API Level 29` and also `API Level 30`.
path: wiki/Installing-Oppia-Android.md
user: login: BenHenning
body: Should be 30 and 34 I think. Robolectric still (probably) uses 30 in Bazel, but we're targeting 34 now for production code.
created_at: 2025-03-14T00:15:27Z
author_association: MEMBER
diff_hunk: @@ -5,32 +5,313 @@ This wiki page explains how to install Oppia Android on your local machine. If y
 ## Table of Contents
 
 - [Prepare developer environment](#prepare-developer-environment)
+- [install Bazel](#install-bazel)
+  - [Bazel setup for Mac](#bazel-set-up-for-mac)
+  - [Bazel setup for Linux](#bazel-set-up-for-linux)
+  - [Bazel setup for Windows](#bazel-set-up-for-windows)
 - [Install oppia-android](#install-oppia-android)
 - [Run the app from Android Studio](#run-the-app-from-android-studio)
+- [Run the app from the command line](#run-the-app-from-the-command-line)
 - [Set up and Run tests](#set-up-and-run-tests)
   - [Step-by-Step guidance for setting up and running app modules robolectric test](#step-by-step-guidance-for-setting-up-and-running-app-modules-robolectric-test)
   - [For tests that are in non-app modules, such as **domain** or **utility**:](#for-tests-that-are-in-non-app-modules-such-as-domain-or-utility)
-
+- [Next Steps](#next-steps)
+- [Troubleshooting Installation](#troubleshooting-installation)
 
 ## Prepare developer environment
 
-1. Download/Install [Android Studio Bumblebee | Patch 3](https://developer.android.com/studio/archive).
-
-   **Note**: We recommend installing **Android Studio Bumblebee | 2021.1.1 Patch 3** because newer versions of Android Studio[ do not support running tests where shared source sets are used](https://issuetracker.google.com/issues/232007221#comment18), a configuration we use at Oppia.
-
-   **Direct download Url**: [Windows](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-windows.exe) | [Linux](https://redirector.gvt1.com/edgedl/android/studio/ide-zips/2021.1.1.23/android-studio-2021.1.1.23-linux.tar.gz) | [Intel Mac](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-mac.dmg) | [Apple Silicon Mac](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-mac_arm.dmg)
-
-   You can have multiple versions of Android Studio installed on your machine at the same time.
+1. Download/Install the latest version of Android Studio from [this location](https://developer.android.com/studio).
+   **Note**: We strongly recommend **Giraffe** because it has been tested and produced the best experience across different OSes.
 
 2. Configure your Android Studio
-   - In Android Studio, open Tools > SDK Manager.
-     - In the "SDK Platforms" tab (which is the default), select `API Level 28` and also `API Level 30` (for Bazel support).
+   - In Android Studio, open **Tools** > **SDK Manager**.
+     - In the "SDK Platforms" tab (which is the default), select `API Level 29` and also `API Level 30`.
      - Also, navigate to the "SDK Tools" tab, click the "Show Package Details" checkbox at the bottom right, then click on "Android SDK Build-Tools 34-rc1" and select 32.0.0 (this is needed for Bazel support).
 
    - Then, click "Apply" to download and install these two SDKs/Tools.
 
-   - Must have **JDK 11** selected:
-     - In Android Studio, open Settings > Build, Execution, Deployment > Build Tools > Gradle and edit the Gradle JDK field.
+3. Prepare a test device
+   You require a physical Android device or an Android emulator to run the Oppia app. 
+   - Physical devices are useful for a real-user experience feel, and testing with [accessibility tools](https://github.com/oppia/oppia-android/wiki/Accessibility-A11y-Guide#setting-up-accessibility-scanner-and-talkback).
+   
+     **Set up a physical device for development**
+      - On the device, open the **Settings** app, select **Developer options**, and then **enable USB debugging** (if applicable).
+        - If you don't see **Developer options**, you might need to enable developer mode first. Follow [these instructions](https://developer.android.com/studio/debug/dev-options#enable) to do so.
+        - Connect to your device using USB.
+        - Verify that your device is connected by running the `adb devices` command from your terminal.
+   
+      - Emulators provide the flexibility of testing the application on a variety of devices and Android API levels without needing to have each physical device.
+   
+     **Set up an Emulator**
+      - For the best experience, you should use the emulator in Android Studio on a computer with at least the following specs:
+        - 16 GB RAM
+        - 64-bit Windows 10 or higher, MacOS 12 or higher, Linux, or ChromeOS operating system
+        - 16 GB disk space
+     
+      - If you don't have these specs, the emulator might still run but not smoothly. In this case, consider testing on a physical device.
+
+       - In Android Studio, in the right hand toolbar, locate `device Manager`.
+       - Click the **+**, and then click **Create Virtual Device**.
+       - Create a phone and a tablet AVD.
path: wiki/Installing-Oppia-Android.md
user: login: BenHenning
body: Probably need to specify the SDK to use. Perhaps we can recommend to always install the SDK version listed above for installation?
created_at: 2025-03-14T00:16:41Z
author_association: MEMBER
diff_hunk: @@ -5,32 +5,313 @@ This wiki page explains how to install Oppia Android on your local machine. If y
 ## Table of Contents
 
 - [Prepare developer environment](#prepare-developer-environment)
+- [install Bazel](#install-bazel)
+  - [Bazel setup for Mac](#bazel-set-up-for-mac)
+  - [Bazel setup for Linux](#bazel-set-up-for-linux)
+  - [Bazel setup for Windows](#bazel-set-up-for-windows)
 - [Install oppia-android](#install-oppia-android)
 - [Run the app from Android Studio](#run-the-app-from-android-studio)
+- [Run the app from the command line](#run-the-app-from-the-command-line)
 - [Set up and Run tests](#set-up-and-run-tests)
   - [Step-by-Step guidance for setting up and running app modules robolectric test](#step-by-step-guidance-for-setting-up-and-running-app-modules-robolectric-test)
   - [For tests that are in non-app modules, such as **domain** or **utility**:](#for-tests-that-are-in-non-app-modules-such-as-domain-or-utility)
-
+- [Next Steps](#next-steps)
+- [Troubleshooting Installation](#troubleshooting-installation)
 
 ## Prepare developer environment
 
-1. Download/Install [Android Studio Bumblebee | Patch 3](https://developer.android.com/studio/archive).
-
-   **Note**: We recommend installing **Android Studio Bumblebee | 2021.1.1 Patch 3** because newer versions of Android Studio[ do not support running tests where shared source sets are used](https://issuetracker.google.com/issues/232007221#comment18), a configuration we use at Oppia.
-
-   **Direct download Url**: [Windows](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-windows.exe) | [Linux](https://redirector.gvt1.com/edgedl/android/studio/ide-zips/2021.1.1.23/android-studio-2021.1.1.23-linux.tar.gz) | [Intel Mac](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-mac.dmg) | [Apple Silicon Mac](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-mac_arm.dmg)
-
-   You can have multiple versions of Android Studio installed on your machine at the same time.
+1. Download/Install the latest version of Android Studio from [this location](https://developer.android.com/studio).
+   **Note**: We strongly recommend **Giraffe** because it has been tested and produced the best experience across different OSes.
 
 2. Configure your Android Studio
-   - In Android Studio, open Tools > SDK Manager.
-     - In the "SDK Platforms" tab (which is the default), select `API Level 28` and also `API Level 30` (for Bazel support).
+   - In Android Studio, open **Tools** > **SDK Manager**.
+     - In the "SDK Platforms" tab (which is the default), select `API Level 29` and also `API Level 30`.
      - Also, navigate to the "SDK Tools" tab, click the "Show Package Details" checkbox at the bottom right, then click on "Android SDK Build-Tools 34-rc1" and select 32.0.0 (this is needed for Bazel support).
 
    - Then, click "Apply" to download and install these two SDKs/Tools.
 
-   - Must have **JDK 11** selected:
-     - In Android Studio, open Settings > Build, Execution, Deployment > Build Tools > Gradle and edit the Gradle JDK field.
+3. Prepare a test device
+   You require a physical Android device or an Android emulator to run the Oppia app. 
+   - Physical devices are useful for a real-user experience feel, and testing with [accessibility tools](https://github.com/oppia/oppia-android/wiki/Accessibility-A11y-Guide#setting-up-accessibility-scanner-and-talkback).
+   
+     **Set up a physical device for development**
+      - On the device, open the **Settings** app, select **Developer options**, and then **enable USB debugging** (if applicable).
+        - If you don't see **Developer options**, you might need to enable developer mode first. Follow [these instructions](https://developer.android.com/studio/debug/dev-options#enable) to do so.
+        - Connect to your device using USB.
+        - Verify that your device is connected by running the `adb devices` command from your terminal.
+   
+      - Emulators provide the flexibility of testing the application on a variety of devices and Android API levels without needing to have each physical device.
+   
+     **Set up an Emulator**
+      - For the best experience, you should use the emulator in Android Studio on a computer with at least the following specs:
+        - 16 GB RAM
+        - 64-bit Windows 10 or higher, MacOS 12 or higher, Linux, or ChromeOS operating system
+        - 16 GB disk space
+     
+      - If you don't have these specs, the emulator might still run but not smoothly. In this case, consider testing on a physical device.
+
+       - In Android Studio, in the right hand toolbar, locate `device Manager`.
+       - Click the **+**, and then click **Create Virtual Device**.
+       - Create a phone and a tablet AVD.
+       - After creating your devices, you will be able to see a list of all the devices on the device manager panel.
+       - For more information on the different configurations available for AVDs, please visit the [official documentation page.](https://developer.android.com/studio/run/managing-avds)
+
+## Install Bazel
+### Instructions
+
+**The steps to setting up Bazel are:**
+1. Install Bazel
+2. Set Bazel and ANDROID_HOME paths permanently in your terminal
+3. Verify that the build is working
+
+The expected output of `bazel --version` once Bazel set up is successful is:
+
+```
+bazel 6.5.0
+```
+
+### Bazel Set up for Mac
+It is recommended to use the binary installer steps outline below. For other ways to install Bazel on Mac, refer to the [official page](https://bazel.build/install/os-x).
+
+**Step 1: Install Xcode command line tools**
+
+In macOS 14 or earlier, it is sufficient to install the Xcode command line tools package by using xcode-select:
+
+```
+xcode-select --install
+```
+
+Otherwise, for macOS 15 and later, you must have Xcode 6.1 or later installed on your system.
+
+Download Xcode from the [App Store](https://apps.apple.com/us/app/xcode/id497799835) or the [Apple Developer site](https://developer.apple.com/download/more/?=xcode).
+
+Once Xcode is installed, accept the license agreement for all users with the following command:
+
+```
+sudo xcodebuild -license accept
+```
+
+**Step 2: Download the Bazel installer**
+
+Click [here](https://github.com/bazelbuild/bazel/releases/download/6.5.0/bazel-6.5.0-installer-darwin-x86_64.sh) to download the Bazel 6.5.0 binary installer.
+
+**Step 3: Run the installer**
+
+Run the Bazel installer as follows:
+
+```shell
+chmod +x "bazel-6.5.0-installer-darwin-x86_64.sh"
+./bazel-6.5.0-installer-darwin-x86_64.sh --user
+```
+
+**Step 4: Set up your environment**
+
+You must set the path for `Bazel` and `ANDROID_HOME` before running bazel build for oppia-android, otherwise you will get an error.
+
+If you ran the Bazel installer with the `--user` flag as above, the Bazel executable is installed in your $HOME/bin directory. It’s a good idea to add this directory to your default paths, as follows:
+
+```shell
+export PATH="$PATH:$HOME/bin"
+```
+
+To set the `ANDROID_HOME` path permanently in your terminal run these commands:
+
+```
+sudo nano /etc/paths
+```
+- Enter your password, when prompted.
+- Go to the bottom of the file, and enter this path: `$HOME/Library/Android/sdk`
+- Hit control-x to quit.
+- Enter “Y” to save the modified buffer.
+- That’s it! To test it, in a new terminal window, type: `echo $PATH`
+
+**Step 5: Verify that the build is working**
+
+Run the following command in your terminal:
+
+```
+bazel --version
+```
+
+### Bazel Set up for Linux
+This section covers Bazel installation on Ubuntu. 
+
+Recommendations:
+- use Ubuntu 18.04 (LTS), 20.04 (LTS), or 22.04 (LTS).
+- use ``apt`` installation instructions.
+
+- **Note**: if you encounter any errors related to `cURL`, please set up cURL on your machine using `sudo apt install curl`.
+
+**Step 1: Add Bazel distribution URI as a package source**
+
+This is a one-time setup step.
+
+```
+sudo apt install apt-transport-https curl gnupg -y
+curl -fsSL https://bazel.build/bazel-release.pub.gpg | gpg --dearmor >bazel-archive-keyring.gpg
+sudo mv bazel-archive-keyring.gpg /usr/share/keyrings
+echo "deb [arch=amd64 signed-by=/usr/share/keyrings/bazel-archive-keyring.gpg] https://storage.googleapis.com/bazel-apt stable jdk1.8" | sudo tee /etc/apt/sources.list.d/bazel.list
+```
+
+**Step 2: Install and update Bazel**
+
+Run:
+```shell
+sudo apt update && sudo apt install bazel-6.5.0
path: wiki/Installing-Oppia-Android.md
user: login: BenHenning
body: ```suggestion
sudo apt-get update && sudo apt-get install bazel-6.5.0
```

`apt` isn't a stable CLI API (which it likes to report :)) and this is when `apt-get` should be used.
created_at: 2025-03-14T00:18:13Z
author_association: MEMBER
diff_hunk: @@ -5,32 +5,313 @@ This wiki page explains how to install Oppia Android on your local machine. If y
 ## Table of Contents
 
 - [Prepare developer environment](#prepare-developer-environment)
+- [install Bazel](#install-bazel)
+  - [Bazel setup for Mac](#bazel-set-up-for-mac)
+  - [Bazel setup for Linux](#bazel-set-up-for-linux)
+  - [Bazel setup for Windows](#bazel-set-up-for-windows)
 - [Install oppia-android](#install-oppia-android)
 - [Run the app from Android Studio](#run-the-app-from-android-studio)
+- [Run the app from the command line](#run-the-app-from-the-command-line)
 - [Set up and Run tests](#set-up-and-run-tests)
   - [Step-by-Step guidance for setting up and running app modules robolectric test](#step-by-step-guidance-for-setting-up-and-running-app-modules-robolectric-test)
   - [For tests that are in non-app modules, such as **domain** or **utility**:](#for-tests-that-are-in-non-app-modules-such-as-domain-or-utility)
-
+- [Next Steps](#next-steps)
+- [Troubleshooting Installation](#troubleshooting-installation)
 
 ## Prepare developer environment
 
-1. Download/Install [Android Studio Bumblebee | Patch 3](https://developer.android.com/studio/archive).
-
-   **Note**: We recommend installing **Android Studio Bumblebee | 2021.1.1 Patch 3** because newer versions of Android Studio[ do not support running tests where shared source sets are used](https://issuetracker.google.com/issues/232007221#comment18), a configuration we use at Oppia.
-
-   **Direct download Url**: [Windows](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-windows.exe) | [Linux](https://redirector.gvt1.com/edgedl/android/studio/ide-zips/2021.1.1.23/android-studio-2021.1.1.23-linux.tar.gz) | [Intel Mac](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-mac.dmg) | [Apple Silicon Mac](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-mac_arm.dmg)
-
-   You can have multiple versions of Android Studio installed on your machine at the same time.
+1. Download/Install the latest version of Android Studio from [this location](https://developer.android.com/studio).
+   **Note**: We strongly recommend **Giraffe** because it has been tested and produced the best experience across different OSes.
 
 2. Configure your Android Studio
-   - In Android Studio, open Tools > SDK Manager.
-     - In the "SDK Platforms" tab (which is the default), select `API Level 28` and also `API Level 30` (for Bazel support).
+   - In Android Studio, open **Tools** > **SDK Manager**.
+     - In the "SDK Platforms" tab (which is the default), select `API Level 29` and also `API Level 30`.
      - Also, navigate to the "SDK Tools" tab, click the "Show Package Details" checkbox at the bottom right, then click on "Android SDK Build-Tools 34-rc1" and select 32.0.0 (this is needed for Bazel support).
 
    - Then, click "Apply" to download and install these two SDKs/Tools.
 
-   - Must have **JDK 11** selected:
-     - In Android Studio, open Settings > Build, Execution, Deployment > Build Tools > Gradle and edit the Gradle JDK field.
+3. Prepare a test device
+   You require a physical Android device or an Android emulator to run the Oppia app. 
+   - Physical devices are useful for a real-user experience feel, and testing with [accessibility tools](https://github.com/oppia/oppia-android/wiki/Accessibility-A11y-Guide#setting-up-accessibility-scanner-and-talkback).
+   
+     **Set up a physical device for development**
+      - On the device, open the **Settings** app, select **Developer options**, and then **enable USB debugging** (if applicable).
+        - If you don't see **Developer options**, you might need to enable developer mode first. Follow [these instructions](https://developer.android.com/studio/debug/dev-options#enable) to do so.
+        - Connect to your device using USB.
+        - Verify that your device is connected by running the `adb devices` command from your terminal.
+   
+      - Emulators provide the flexibility of testing the application on a variety of devices and Android API levels without needing to have each physical device.
+   
+     **Set up an Emulator**
+      - For the best experience, you should use the emulator in Android Studio on a computer with at least the following specs:
+        - 16 GB RAM
+        - 64-bit Windows 10 or higher, MacOS 12 or higher, Linux, or ChromeOS operating system
+        - 16 GB disk space
+     
+      - If you don't have these specs, the emulator might still run but not smoothly. In this case, consider testing on a physical device.
+
+       - In Android Studio, in the right hand toolbar, locate `device Manager`.
+       - Click the **+**, and then click **Create Virtual Device**.
+       - Create a phone and a tablet AVD.
+       - After creating your devices, you will be able to see a list of all the devices on the device manager panel.
+       - For more information on the different configurations available for AVDs, please visit the [official documentation page.](https://developer.android.com/studio/run/managing-avds)
+
+## Install Bazel
+### Instructions
+
+**The steps to setting up Bazel are:**
+1. Install Bazel
+2. Set Bazel and ANDROID_HOME paths permanently in your terminal
+3. Verify that the build is working
+
+The expected output of `bazel --version` once Bazel set up is successful is:
+
+```
+bazel 6.5.0
+```
+
+### Bazel Set up for Mac
+It is recommended to use the binary installer steps outline below. For other ways to install Bazel on Mac, refer to the [official page](https://bazel.build/install/os-x).
+
+**Step 1: Install Xcode command line tools**
+
+In macOS 14 or earlier, it is sufficient to install the Xcode command line tools package by using xcode-select:
+
+```
+xcode-select --install
+```
+
+Otherwise, for macOS 15 and later, you must have Xcode 6.1 or later installed on your system.
+
+Download Xcode from the [App Store](https://apps.apple.com/us/app/xcode/id497799835) or the [Apple Developer site](https://developer.apple.com/download/more/?=xcode).
+
+Once Xcode is installed, accept the license agreement for all users with the following command:
+
+```
+sudo xcodebuild -license accept
+```
+
+**Step 2: Download the Bazel installer**
+
+Click [here](https://github.com/bazelbuild/bazel/releases/download/6.5.0/bazel-6.5.0-installer-darwin-x86_64.sh) to download the Bazel 6.5.0 binary installer.
+
+**Step 3: Run the installer**
+
+Run the Bazel installer as follows:
+
+```shell
+chmod +x "bazel-6.5.0-installer-darwin-x86_64.sh"
+./bazel-6.5.0-installer-darwin-x86_64.sh --user
+```
+
+**Step 4: Set up your environment**
+
+You must set the path for `Bazel` and `ANDROID_HOME` before running bazel build for oppia-android, otherwise you will get an error.
+
+If you ran the Bazel installer with the `--user` flag as above, the Bazel executable is installed in your $HOME/bin directory. It’s a good idea to add this directory to your default paths, as follows:
+
+```shell
+export PATH="$PATH:$HOME/bin"
+```
+
+To set the `ANDROID_HOME` path permanently in your terminal run these commands:
+
+```
+sudo nano /etc/paths
+```
+- Enter your password, when prompted.
+- Go to the bottom of the file, and enter this path: `$HOME/Library/Android/sdk`
+- Hit control-x to quit.
+- Enter “Y” to save the modified buffer.
+- That’s it! To test it, in a new terminal window, type: `echo $PATH`
+
+**Step 5: Verify that the build is working**
+
+Run the following command in your terminal:
+
+```
+bazel --version
+```
+
+### Bazel Set up for Linux
+This section covers Bazel installation on Ubuntu. 
+
+Recommendations:
+- use Ubuntu 18.04 (LTS), 20.04 (LTS), or 22.04 (LTS).
+- use ``apt`` installation instructions.
+
+- **Note**: if you encounter any errors related to `cURL`, please set up cURL on your machine using `sudo apt install curl`.
+
+**Step 1: Add Bazel distribution URI as a package source**
+
+This is a one-time setup step.
+
+```
+sudo apt install apt-transport-https curl gnupg -y
+curl -fsSL https://bazel.build/bazel-release.pub.gpg | gpg --dearmor >bazel-archive-keyring.gpg
+sudo mv bazel-archive-keyring.gpg /usr/share/keyrings
+echo "deb [arch=amd64 signed-by=/usr/share/keyrings/bazel-archive-keyring.gpg] https://storage.googleapis.com/bazel-apt stable jdk1.8" | sudo tee /etc/apt/sources.list.d/bazel.list
+```
+
+**Step 2: Install and update Bazel**
+
+Run:
+```shell
+sudo apt update && sudo apt install bazel-6.5.0
+```
+
+**Step 3: Set up your environment**
+
+Ensure that your `ANDROID_HOME` environment variable is set to the location of your Android SDK. To do this, find the path to the installed SDK using Android Studio’s SDK Manager (install SDK 28). Assuming the SDK is installed to default locations, you can use the following commands to set the `ANDROID_HOME` variable:<br>
path: wiki/Installing-Oppia-Android.md
user: login: BenHenning
body: Strike 'install SDK 28' here as it contradicts the installation above. We should provide instructions in one location for setting up the SDK, no need to repeat it.

Also, can the `<br>` be removed? Not sure why we need it here.
created_at: 2025-03-14T00:19:15Z
author_association: MEMBER
diff_hunk: @@ -5,32 +5,313 @@ This wiki page explains how to install Oppia Android on your local machine. If y
 ## Table of Contents
 
 - [Prepare developer environment](#prepare-developer-environment)
+- [install Bazel](#install-bazel)
+  - [Bazel setup for Mac](#bazel-set-up-for-mac)
+  - [Bazel setup for Linux](#bazel-set-up-for-linux)
+  - [Bazel setup for Windows](#bazel-set-up-for-windows)
 - [Install oppia-android](#install-oppia-android)
 - [Run the app from Android Studio](#run-the-app-from-android-studio)
+- [Run the app from the command line](#run-the-app-from-the-command-line)
 - [Set up and Run tests](#set-up-and-run-tests)
   - [Step-by-Step guidance for setting up and running app modules robolectric test](#step-by-step-guidance-for-setting-up-and-running-app-modules-robolectric-test)
   - [For tests that are in non-app modules, such as **domain** or **utility**:](#for-tests-that-are-in-non-app-modules-such-as-domain-or-utility)
-
+- [Next Steps](#next-steps)
+- [Troubleshooting Installation](#troubleshooting-installation)
 
 ## Prepare developer environment
 
-1. Download/Install [Android Studio Bumblebee | Patch 3](https://developer.android.com/studio/archive).
-
-   **Note**: We recommend installing **Android Studio Bumblebee | 2021.1.1 Patch 3** because newer versions of Android Studio[ do not support running tests where shared source sets are used](https://issuetracker.google.com/issues/232007221#comment18), a configuration we use at Oppia.
-
-   **Direct download Url**: [Windows](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-windows.exe) | [Linux](https://redirector.gvt1.com/edgedl/android/studio/ide-zips/2021.1.1.23/android-studio-2021.1.1.23-linux.tar.gz) | [Intel Mac](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-mac.dmg) | [Apple Silicon Mac](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-mac_arm.dmg)
-
-   You can have multiple versions of Android Studio installed on your machine at the same time.
+1. Download/Install the latest version of Android Studio from [this location](https://developer.android.com/studio).
+   **Note**: We strongly recommend **Giraffe** because it has been tested and produced the best experience across different OSes.
 
 2. Configure your Android Studio
-   - In Android Studio, open Tools > SDK Manager.
-     - In the "SDK Platforms" tab (which is the default), select `API Level 28` and also `API Level 30` (for Bazel support).
+   - In Android Studio, open **Tools** > **SDK Manager**.
+     - In the "SDK Platforms" tab (which is the default), select `API Level 29` and also `API Level 30`.
      - Also, navigate to the "SDK Tools" tab, click the "Show Package Details" checkbox at the bottom right, then click on "Android SDK Build-Tools 34-rc1" and select 32.0.0 (this is needed for Bazel support).
 
    - Then, click "Apply" to download and install these two SDKs/Tools.
 
-   - Must have **JDK 11** selected:
-     - In Android Studio, open Settings > Build, Execution, Deployment > Build Tools > Gradle and edit the Gradle JDK field.
+3. Prepare a test device
+   You require a physical Android device or an Android emulator to run the Oppia app. 
+   - Physical devices are useful for a real-user experience feel, and testing with [accessibility tools](https://github.com/oppia/oppia-android/wiki/Accessibility-A11y-Guide#setting-up-accessibility-scanner-and-talkback).
+   
+     **Set up a physical device for development**
+      - On the device, open the **Settings** app, select **Developer options**, and then **enable USB debugging** (if applicable).
+        - If you don't see **Developer options**, you might need to enable developer mode first. Follow [these instructions](https://developer.android.com/studio/debug/dev-options#enable) to do so.
+        - Connect to your device using USB.
+        - Verify that your device is connected by running the `adb devices` command from your terminal.
+   
+      - Emulators provide the flexibility of testing the application on a variety of devices and Android API levels without needing to have each physical device.
+   
+     **Set up an Emulator**
+      - For the best experience, you should use the emulator in Android Studio on a computer with at least the following specs:
+        - 16 GB RAM
+        - 64-bit Windows 10 or higher, MacOS 12 or higher, Linux, or ChromeOS operating system
+        - 16 GB disk space
+     
+      - If you don't have these specs, the emulator might still run but not smoothly. In this case, consider testing on a physical device.
+
+       - In Android Studio, in the right hand toolbar, locate `device Manager`.
+       - Click the **+**, and then click **Create Virtual Device**.
+       - Create a phone and a tablet AVD.
+       - After creating your devices, you will be able to see a list of all the devices on the device manager panel.
+       - For more information on the different configurations available for AVDs, please visit the [official documentation page.](https://developer.android.com/studio/run/managing-avds)
+
+## Install Bazel
+### Instructions
+
+**The steps to setting up Bazel are:**
+1. Install Bazel
+2. Set Bazel and ANDROID_HOME paths permanently in your terminal
+3. Verify that the build is working
+
+The expected output of `bazel --version` once Bazel set up is successful is:
+
+```
+bazel 6.5.0
+```
+
+### Bazel Set up for Mac
+It is recommended to use the binary installer steps outline below. For other ways to install Bazel on Mac, refer to the [official page](https://bazel.build/install/os-x).
+
+**Step 1: Install Xcode command line tools**
+
+In macOS 14 or earlier, it is sufficient to install the Xcode command line tools package by using xcode-select:
+
+```
+xcode-select --install
+```
+
+Otherwise, for macOS 15 and later, you must have Xcode 6.1 or later installed on your system.
+
+Download Xcode from the [App Store](https://apps.apple.com/us/app/xcode/id497799835) or the [Apple Developer site](https://developer.apple.com/download/more/?=xcode).
+
+Once Xcode is installed, accept the license agreement for all users with the following command:
+
+```
+sudo xcodebuild -license accept
+```
+
+**Step 2: Download the Bazel installer**
+
+Click [here](https://github.com/bazelbuild/bazel/releases/download/6.5.0/bazel-6.5.0-installer-darwin-x86_64.sh) to download the Bazel 6.5.0 binary installer.
+
+**Step 3: Run the installer**
+
+Run the Bazel installer as follows:
+
+```shell
+chmod +x "bazel-6.5.0-installer-darwin-x86_64.sh"
+./bazel-6.5.0-installer-darwin-x86_64.sh --user
+```
+
+**Step 4: Set up your environment**
+
+You must set the path for `Bazel` and `ANDROID_HOME` before running bazel build for oppia-android, otherwise you will get an error.
+
+If you ran the Bazel installer with the `--user` flag as above, the Bazel executable is installed in your $HOME/bin directory. It’s a good idea to add this directory to your default paths, as follows:
+
+```shell
+export PATH="$PATH:$HOME/bin"
+```
+
+To set the `ANDROID_HOME` path permanently in your terminal run these commands:
+
+```
+sudo nano /etc/paths
+```
+- Enter your password, when prompted.
+- Go to the bottom of the file, and enter this path: `$HOME/Library/Android/sdk`
+- Hit control-x to quit.
+- Enter “Y” to save the modified buffer.
+- That’s it! To test it, in a new terminal window, type: `echo $PATH`
+
+**Step 5: Verify that the build is working**
+
+Run the following command in your terminal:
+
+```
+bazel --version
+```
+
+### Bazel Set up for Linux
+This section covers Bazel installation on Ubuntu. 
+
+Recommendations:
+- use Ubuntu 18.04 (LTS), 20.04 (LTS), or 22.04 (LTS).
+- use ``apt`` installation instructions.
+
+- **Note**: if you encounter any errors related to `cURL`, please set up cURL on your machine using `sudo apt install curl`.
+
+**Step 1: Add Bazel distribution URI as a package source**
+
+This is a one-time setup step.
+
+```
+sudo apt install apt-transport-https curl gnupg -y
+curl -fsSL https://bazel.build/bazel-release.pub.gpg | gpg --dearmor >bazel-archive-keyring.gpg
+sudo mv bazel-archive-keyring.gpg /usr/share/keyrings
+echo "deb [arch=amd64 signed-by=/usr/share/keyrings/bazel-archive-keyring.gpg] https://storage.googleapis.com/bazel-apt stable jdk1.8" | sudo tee /etc/apt/sources.list.d/bazel.list
+```
+
+**Step 2: Install and update Bazel**
+
+Run:
+```shell
+sudo apt update && sudo apt install bazel-6.5.0
+```
+
+**Step 3: Set up your environment**
+
+Ensure that your `ANDROID_HOME` environment variable is set to the location of your Android SDK. To do this, find the path to the installed SDK using Android Studio’s SDK Manager (install SDK 28). Assuming the SDK is installed to default locations, you can use the following commands to set the `ANDROID_HOME` variable:<br>
+```
+export ANDROID_HOME=$HOME/Android/Sdk/
+```
+
+**Step 4: Verify that the build is working**
+
+Run the following command in your terminal:
+
+```
+bazel --version
+```
+
+### Bazel Set up for Windows
+This page outlines one way to allow Bazel to be used in CLI form on Windows. Please note that **this support is currently experimental**. You may run into some problems--we suggest that you post a discussion at [github-discussions](https://github.com/oppia/oppia-android/discussions).
path: wiki/Installing-Oppia-Android.md
user: login: BenHenning
body: ```suggestion
This page outlines one way to allow Bazel to be used in CLI form on Windows. Please note that **this support is currently experimental**. We suggest that you post a discussion at [github-discussions](https://github.com/oppia/oppia-android/discussions) if you run into any problems.
```
created_at: 2025-03-14T00:20:00Z
author_association: MEMBER
diff_hunk: @@ -5,32 +5,313 @@ This wiki page explains how to install Oppia Android on your local machine. If y
 ## Table of Contents
 
 - [Prepare developer environment](#prepare-developer-environment)
+- [install Bazel](#install-bazel)
+  - [Bazel setup for Mac](#bazel-set-up-for-mac)
+  - [Bazel setup for Linux](#bazel-set-up-for-linux)
+  - [Bazel setup for Windows](#bazel-set-up-for-windows)
 - [Install oppia-android](#install-oppia-android)
 - [Run the app from Android Studio](#run-the-app-from-android-studio)
+- [Run the app from the command line](#run-the-app-from-the-command-line)
 - [Set up and Run tests](#set-up-and-run-tests)
   - [Step-by-Step guidance for setting up and running app modules robolectric test](#step-by-step-guidance-for-setting-up-and-running-app-modules-robolectric-test)
   - [For tests that are in non-app modules, such as **domain** or **utility**:](#for-tests-that-are-in-non-app-modules-such-as-domain-or-utility)
-
+- [Next Steps](#next-steps)
+- [Troubleshooting Installation](#troubleshooting-installation)
 
 ## Prepare developer environment
 
-1. Download/Install [Android Studio Bumblebee | Patch 3](https://developer.android.com/studio/archive).
-
-   **Note**: We recommend installing **Android Studio Bumblebee | 2021.1.1 Patch 3** because newer versions of Android Studio[ do not support running tests where shared source sets are used](https://issuetracker.google.com/issues/232007221#comment18), a configuration we use at Oppia.
-
-   **Direct download Url**: [Windows](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-windows.exe) | [Linux](https://redirector.gvt1.com/edgedl/android/studio/ide-zips/2021.1.1.23/android-studio-2021.1.1.23-linux.tar.gz) | [Intel Mac](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-mac.dmg) | [Apple Silicon Mac](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-mac_arm.dmg)
-
-   You can have multiple versions of Android Studio installed on your machine at the same time.
+1. Download/Install the latest version of Android Studio from [this location](https://developer.android.com/studio).
+   **Note**: We strongly recommend **Giraffe** because it has been tested and produced the best experience across different OSes.
 
 2. Configure your Android Studio
-   - In Android Studio, open Tools > SDK Manager.
-     - In the "SDK Platforms" tab (which is the default), select `API Level 28` and also `API Level 30` (for Bazel support).
+   - In Android Studio, open **Tools** > **SDK Manager**.
+     - In the "SDK Platforms" tab (which is the default), select `API Level 29` and also `API Level 30`.
      - Also, navigate to the "SDK Tools" tab, click the "Show Package Details" checkbox at the bottom right, then click on "Android SDK Build-Tools 34-rc1" and select 32.0.0 (this is needed for Bazel support).
 
    - Then, click "Apply" to download and install these two SDKs/Tools.
 
-   - Must have **JDK 11** selected:
-     - In Android Studio, open Settings > Build, Execution, Deployment > Build Tools > Gradle and edit the Gradle JDK field.
+3. Prepare a test device
+   You require a physical Android device or an Android emulator to run the Oppia app. 
+   - Physical devices are useful for a real-user experience feel, and testing with [accessibility tools](https://github.com/oppia/oppia-android/wiki/Accessibility-A11y-Guide#setting-up-accessibility-scanner-and-talkback).
+   
+     **Set up a physical device for development**
+      - On the device, open the **Settings** app, select **Developer options**, and then **enable USB debugging** (if applicable).
+        - If you don't see **Developer options**, you might need to enable developer mode first. Follow [these instructions](https://developer.android.com/studio/debug/dev-options#enable) to do so.
+        - Connect to your device using USB.
+        - Verify that your device is connected by running the `adb devices` command from your terminal.
+   
+      - Emulators provide the flexibility of testing the application on a variety of devices and Android API levels without needing to have each physical device.
+   
+     **Set up an Emulator**
+      - For the best experience, you should use the emulator in Android Studio on a computer with at least the following specs:
+        - 16 GB RAM
+        - 64-bit Windows 10 or higher, MacOS 12 or higher, Linux, or ChromeOS operating system
+        - 16 GB disk space
+     
+      - If you don't have these specs, the emulator might still run but not smoothly. In this case, consider testing on a physical device.
+
+       - In Android Studio, in the right hand toolbar, locate `device Manager`.
+       - Click the **+**, and then click **Create Virtual Device**.
+       - Create a phone and a tablet AVD.
+       - After creating your devices, you will be able to see a list of all the devices on the device manager panel.
+       - For more information on the different configurations available for AVDs, please visit the [official documentation page.](https://developer.android.com/studio/run/managing-avds)
+
+## Install Bazel
+### Instructions
+
+**The steps to setting up Bazel are:**
+1. Install Bazel
+2. Set Bazel and ANDROID_HOME paths permanently in your terminal
+3. Verify that the build is working
+
+The expected output of `bazel --version` once Bazel set up is successful is:
+
+```
+bazel 6.5.0
+```
+
+### Bazel Set up for Mac
+It is recommended to use the binary installer steps outline below. For other ways to install Bazel on Mac, refer to the [official page](https://bazel.build/install/os-x).
+
+**Step 1: Install Xcode command line tools**
+
+In macOS 14 or earlier, it is sufficient to install the Xcode command line tools package by using xcode-select:
+
+```
+xcode-select --install
+```
+
+Otherwise, for macOS 15 and later, you must have Xcode 6.1 or later installed on your system.
+
+Download Xcode from the [App Store](https://apps.apple.com/us/app/xcode/id497799835) or the [Apple Developer site](https://developer.apple.com/download/more/?=xcode).
+
+Once Xcode is installed, accept the license agreement for all users with the following command:
+
+```
+sudo xcodebuild -license accept
+```
+
+**Step 2: Download the Bazel installer**
+
+Click [here](https://github.com/bazelbuild/bazel/releases/download/6.5.0/bazel-6.5.0-installer-darwin-x86_64.sh) to download the Bazel 6.5.0 binary installer.
+
+**Step 3: Run the installer**
+
+Run the Bazel installer as follows:
+
+```shell
+chmod +x "bazel-6.5.0-installer-darwin-x86_64.sh"
+./bazel-6.5.0-installer-darwin-x86_64.sh --user
+```
+
+**Step 4: Set up your environment**
+
+You must set the path for `Bazel` and `ANDROID_HOME` before running bazel build for oppia-android, otherwise you will get an error.
+
+If you ran the Bazel installer with the `--user` flag as above, the Bazel executable is installed in your $HOME/bin directory. It’s a good idea to add this directory to your default paths, as follows:
+
+```shell
+export PATH="$PATH:$HOME/bin"
+```
+
+To set the `ANDROID_HOME` path permanently in your terminal run these commands:
+
+```
+sudo nano /etc/paths
+```
+- Enter your password, when prompted.
+- Go to the bottom of the file, and enter this path: `$HOME/Library/Android/sdk`
+- Hit control-x to quit.
+- Enter “Y” to save the modified buffer.
+- That’s it! To test it, in a new terminal window, type: `echo $PATH`
+
+**Step 5: Verify that the build is working**
+
+Run the following command in your terminal:
+
+```
+bazel --version
+```
+
+### Bazel Set up for Linux
+This section covers Bazel installation on Ubuntu. 
+
+Recommendations:
+- use Ubuntu 18.04 (LTS), 20.04 (LTS), or 22.04 (LTS).
+- use ``apt`` installation instructions.
+
+- **Note**: if you encounter any errors related to `cURL`, please set up cURL on your machine using `sudo apt install curl`.
+
+**Step 1: Add Bazel distribution URI as a package source**
+
+This is a one-time setup step.
+
+```
+sudo apt install apt-transport-https curl gnupg -y
+curl -fsSL https://bazel.build/bazel-release.pub.gpg | gpg --dearmor >bazel-archive-keyring.gpg
+sudo mv bazel-archive-keyring.gpg /usr/share/keyrings
+echo "deb [arch=amd64 signed-by=/usr/share/keyrings/bazel-archive-keyring.gpg] https://storage.googleapis.com/bazel-apt stable jdk1.8" | sudo tee /etc/apt/sources.list.d/bazel.list
+```
+
+**Step 2: Install and update Bazel**
+
+Run:
+```shell
+sudo apt update && sudo apt install bazel-6.5.0
+```
+
+**Step 3: Set up your environment**
+
+Ensure that your `ANDROID_HOME` environment variable is set to the location of your Android SDK. To do this, find the path to the installed SDK using Android Studio’s SDK Manager (install SDK 28). Assuming the SDK is installed to default locations, you can use the following commands to set the `ANDROID_HOME` variable:<br>
+```
+export ANDROID_HOME=$HOME/Android/Sdk/
+```
+
+**Step 4: Verify that the build is working**
+
+Run the following command in your terminal:
+
+```
+bazel --version
+```
+
+### Bazel Set up for Windows
+This page outlines one way to allow Bazel to be used in CLI form on Windows. Please note that **this support is currently experimental**. You may run into some problems--we suggest that you post a discussion at [github-discussions](https://github.com/oppia/oppia-android/discussions).
+
+Unlike Unix-based systems where Bazel runs natively without issue, the current solution on Windows is to install an Ubuntu-based subsystem. Windows currently only supports a terminal experience in this subsystem (though there is a prerelease version of the software with GUI support) which means Android Studio will not be supported. You will need to continue using the Windows version of Android Studio and only use the Linux subsystem for building & running Robolectric or JUnit-based tests.
+
+Due to the issues mentioned above, we recommend dual-booting your PC with Linux. However, if you choose to use windows, please follow the instructions below:
path: wiki/Installing-Oppia-Android.md
user: login: BenHenning
body: ```suggestion
Due to the issues mentioned above, we recommend dual-booting your PC with Linux. However, if you choose to use Windows, please follow the instructions below:
```
created_at: 2025-03-14T00:20:25Z
author_association: MEMBER
diff_hunk: @@ -5,32 +5,313 @@ This wiki page explains how to install Oppia Android on your local machine. If y
 ## Table of Contents
 
 - [Prepare developer environment](#prepare-developer-environment)
+- [install Bazel](#install-bazel)
+  - [Bazel setup for Mac](#bazel-set-up-for-mac)
+  - [Bazel setup for Linux](#bazel-set-up-for-linux)
+  - [Bazel setup for Windows](#bazel-set-up-for-windows)
 - [Install oppia-android](#install-oppia-android)
 - [Run the app from Android Studio](#run-the-app-from-android-studio)
+- [Run the app from the command line](#run-the-app-from-the-command-line)
 - [Set up and Run tests](#set-up-and-run-tests)
   - [Step-by-Step guidance for setting up and running app modules robolectric test](#step-by-step-guidance-for-setting-up-and-running-app-modules-robolectric-test)
   - [For tests that are in non-app modules, such as **domain** or **utility**:](#for-tests-that-are-in-non-app-modules-such-as-domain-or-utility)
-
+- [Next Steps](#next-steps)
+- [Troubleshooting Installation](#troubleshooting-installation)
 
 ## Prepare developer environment
 
-1. Download/Install [Android Studio Bumblebee | Patch 3](https://developer.android.com/studio/archive).
-
-   **Note**: We recommend installing **Android Studio Bumblebee | 2021.1.1 Patch 3** because newer versions of Android Studio[ do not support running tests where shared source sets are used](https://issuetracker.google.com/issues/232007221#comment18), a configuration we use at Oppia.
-
-   **Direct download Url**: [Windows](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-windows.exe) | [Linux](https://redirector.gvt1.com/edgedl/android/studio/ide-zips/2021.1.1.23/android-studio-2021.1.1.23-linux.tar.gz) | [Intel Mac](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-mac.dmg) | [Apple Silicon Mac](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-mac_arm.dmg)
-
-   You can have multiple versions of Android Studio installed on your machine at the same time.
+1. Download/Install the latest version of Android Studio from [this location](https://developer.android.com/studio).
+   **Note**: We strongly recommend **Giraffe** because it has been tested and produced the best experience across different OSes.
 
 2. Configure your Android Studio
-   - In Android Studio, open Tools > SDK Manager.
-     - In the "SDK Platforms" tab (which is the default), select `API Level 28` and also `API Level 30` (for Bazel support).
+   - In Android Studio, open **Tools** > **SDK Manager**.
+     - In the "SDK Platforms" tab (which is the default), select `API Level 29` and also `API Level 30`.
      - Also, navigate to the "SDK Tools" tab, click the "Show Package Details" checkbox at the bottom right, then click on "Android SDK Build-Tools 34-rc1" and select 32.0.0 (this is needed for Bazel support).
 
    - Then, click "Apply" to download and install these two SDKs/Tools.
 
-   - Must have **JDK 11** selected:
-     - In Android Studio, open Settings > Build, Execution, Deployment > Build Tools > Gradle and edit the Gradle JDK field.
+3. Prepare a test device
+   You require a physical Android device or an Android emulator to run the Oppia app. 
+   - Physical devices are useful for a real-user experience feel, and testing with [accessibility tools](https://github.com/oppia/oppia-android/wiki/Accessibility-A11y-Guide#setting-up-accessibility-scanner-and-talkback).
+   
+     **Set up a physical device for development**
+      - On the device, open the **Settings** app, select **Developer options**, and then **enable USB debugging** (if applicable).
+        - If you don't see **Developer options**, you might need to enable developer mode first. Follow [these instructions](https://developer.android.com/studio/debug/dev-options#enable) to do so.
+        - Connect to your device using USB.
+        - Verify that your device is connected by running the `adb devices` command from your terminal.
+   
+      - Emulators provide the flexibility of testing the application on a variety of devices and Android API levels without needing to have each physical device.
+   
+     **Set up an Emulator**
+      - For the best experience, you should use the emulator in Android Studio on a computer with at least the following specs:
+        - 16 GB RAM
+        - 64-bit Windows 10 or higher, MacOS 12 or higher, Linux, or ChromeOS operating system
+        - 16 GB disk space
+     
+      - If you don't have these specs, the emulator might still run but not smoothly. In this case, consider testing on a physical device.
+
+       - In Android Studio, in the right hand toolbar, locate `device Manager`.
+       - Click the **+**, and then click **Create Virtual Device**.
+       - Create a phone and a tablet AVD.
+       - After creating your devices, you will be able to see a list of all the devices on the device manager panel.
+       - For more information on the different configurations available for AVDs, please visit the [official documentation page.](https://developer.android.com/studio/run/managing-avds)
+
+## Install Bazel
+### Instructions
+
+**The steps to setting up Bazel are:**
+1. Install Bazel
+2. Set Bazel and ANDROID_HOME paths permanently in your terminal
+3. Verify that the build is working
+
+The expected output of `bazel --version` once Bazel set up is successful is:
+
+```
+bazel 6.5.0
+```
+
+### Bazel Set up for Mac
+It is recommended to use the binary installer steps outline below. For other ways to install Bazel on Mac, refer to the [official page](https://bazel.build/install/os-x).
+
+**Step 1: Install Xcode command line tools**
+
+In macOS 14 or earlier, it is sufficient to install the Xcode command line tools package by using xcode-select:
+
+```
+xcode-select --install
+```
+
+Otherwise, for macOS 15 and later, you must have Xcode 6.1 or later installed on your system.
+
+Download Xcode from the [App Store](https://apps.apple.com/us/app/xcode/id497799835) or the [Apple Developer site](https://developer.apple.com/download/more/?=xcode).
+
+Once Xcode is installed, accept the license agreement for all users with the following command:
+
+```
+sudo xcodebuild -license accept
+```
+
+**Step 2: Download the Bazel installer**
+
+Click [here](https://github.com/bazelbuild/bazel/releases/download/6.5.0/bazel-6.5.0-installer-darwin-x86_64.sh) to download the Bazel 6.5.0 binary installer.
+
+**Step 3: Run the installer**
+
+Run the Bazel installer as follows:
+
+```shell
+chmod +x "bazel-6.5.0-installer-darwin-x86_64.sh"
+./bazel-6.5.0-installer-darwin-x86_64.sh --user
+```
+
+**Step 4: Set up your environment**
+
+You must set the path for `Bazel` and `ANDROID_HOME` before running bazel build for oppia-android, otherwise you will get an error.
+
+If you ran the Bazel installer with the `--user` flag as above, the Bazel executable is installed in your $HOME/bin directory. It’s a good idea to add this directory to your default paths, as follows:
+
+```shell
+export PATH="$PATH:$HOME/bin"
+```
+
+To set the `ANDROID_HOME` path permanently in your terminal run these commands:
+
+```
+sudo nano /etc/paths
+```
+- Enter your password, when prompted.
+- Go to the bottom of the file, and enter this path: `$HOME/Library/Android/sdk`
+- Hit control-x to quit.
+- Enter “Y” to save the modified buffer.
+- That’s it! To test it, in a new terminal window, type: `echo $PATH`
+
+**Step 5: Verify that the build is working**
+
+Run the following command in your terminal:
+
+```
+bazel --version
+```
+
+### Bazel Set up for Linux
+This section covers Bazel installation on Ubuntu. 
+
+Recommendations:
+- use Ubuntu 18.04 (LTS), 20.04 (LTS), or 22.04 (LTS).
+- use ``apt`` installation instructions.
+
+- **Note**: if you encounter any errors related to `cURL`, please set up cURL on your machine using `sudo apt install curl`.
+
+**Step 1: Add Bazel distribution URI as a package source**
+
+This is a one-time setup step.
+
+```
+sudo apt install apt-transport-https curl gnupg -y
+curl -fsSL https://bazel.build/bazel-release.pub.gpg | gpg --dearmor >bazel-archive-keyring.gpg
+sudo mv bazel-archive-keyring.gpg /usr/share/keyrings
+echo "deb [arch=amd64 signed-by=/usr/share/keyrings/bazel-archive-keyring.gpg] https://storage.googleapis.com/bazel-apt stable jdk1.8" | sudo tee /etc/apt/sources.list.d/bazel.list
+```
+
+**Step 2: Install and update Bazel**
+
+Run:
+```shell
+sudo apt update && sudo apt install bazel-6.5.0
+```
+
+**Step 3: Set up your environment**
+
+Ensure that your `ANDROID_HOME` environment variable is set to the location of your Android SDK. To do this, find the path to the installed SDK using Android Studio’s SDK Manager (install SDK 28). Assuming the SDK is installed to default locations, you can use the following commands to set the `ANDROID_HOME` variable:<br>
+```
+export ANDROID_HOME=$HOME/Android/Sdk/
+```
+
+**Step 4: Verify that the build is working**
+
+Run the following command in your terminal:
+
+```
+bazel --version
+```
+
+### Bazel Set up for Windows
+This page outlines one way to allow Bazel to be used in CLI form on Windows. Please note that **this support is currently experimental**. You may run into some problems--we suggest that you post a discussion at [github-discussions](https://github.com/oppia/oppia-android/discussions).
+
+Unlike Unix-based systems where Bazel runs natively without issue, the current solution on Windows is to install an Ubuntu-based subsystem. Windows currently only supports a terminal experience in this subsystem (though there is a prerelease version of the software with GUI support) which means Android Studio will not be supported. You will need to continue using the Windows version of Android Studio and only use the Linux subsystem for building & running Robolectric or JUnit-based tests.
+
+Due to the issues mentioned above, we recommend dual-booting your PC with Linux. However, if you choose to use windows, please follow the instructions below:
+
+**Main prerequisites**:
+- Windows 10: These instructions are geared towards users of Windows 10 (older versions will not be compatible). If you're in using an older version of Windows, please follow up with a comment on [this issue](https://github.com/oppia/oppia-android/issues/3371).
path: wiki/Installing-Oppia-Android.md
user: login: BenHenning
body: @Rd4dev can we say 'Windows 11' here, instead? Windows 10 is no longer supported by MS and we should probably refer to the correct thing (assuming it actually works with the same instructions).

Ditto for the Windows 10 reference below.
created_at: 2025-03-14T00:21:25Z
author_association: MEMBER
diff_hunk: @@ -5,32 +5,313 @@ This wiki page explains how to install Oppia Android on your local machine. If y
 ## Table of Contents
 
 - [Prepare developer environment](#prepare-developer-environment)
+- [install Bazel](#install-bazel)
+  - [Bazel setup for Mac](#bazel-set-up-for-mac)
+  - [Bazel setup for Linux](#bazel-set-up-for-linux)
+  - [Bazel setup for Windows](#bazel-set-up-for-windows)
 - [Install oppia-android](#install-oppia-android)
 - [Run the app from Android Studio](#run-the-app-from-android-studio)
+- [Run the app from the command line](#run-the-app-from-the-command-line)
 - [Set up and Run tests](#set-up-and-run-tests)
   - [Step-by-Step guidance for setting up and running app modules robolectric test](#step-by-step-guidance-for-setting-up-and-running-app-modules-robolectric-test)
   - [For tests that are in non-app modules, such as **domain** or **utility**:](#for-tests-that-are-in-non-app-modules-such-as-domain-or-utility)
-
+- [Next Steps](#next-steps)
+- [Troubleshooting Installation](#troubleshooting-installation)
 
 ## Prepare developer environment
 
-1. Download/Install [Android Studio Bumblebee | Patch 3](https://developer.android.com/studio/archive).
-
-   **Note**: We recommend installing **Android Studio Bumblebee | 2021.1.1 Patch 3** because newer versions of Android Studio[ do not support running tests where shared source sets are used](https://issuetracker.google.com/issues/232007221#comment18), a configuration we use at Oppia.
-
-   **Direct download Url**: [Windows](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-windows.exe) | [Linux](https://redirector.gvt1.com/edgedl/android/studio/ide-zips/2021.1.1.23/android-studio-2021.1.1.23-linux.tar.gz) | [Intel Mac](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-mac.dmg) | [Apple Silicon Mac](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-mac_arm.dmg)
-
-   You can have multiple versions of Android Studio installed on your machine at the same time.
+1. Download/Install the latest version of Android Studio from [this location](https://developer.android.com/studio).
+   **Note**: We strongly recommend **Giraffe** because it has been tested and produced the best experience across different OSes.
 
 2. Configure your Android Studio
-   - In Android Studio, open Tools > SDK Manager.
-     - In the "SDK Platforms" tab (which is the default), select `API Level 28` and also `API Level 30` (for Bazel support).
+   - In Android Studio, open **Tools** > **SDK Manager**.
path: wiki/Installing-Oppia-Android.md
user: login: BenHenning
body: These instructions should be framed before opening the project--are they still understandable in that context? Android Studio's out of box experience can be a bit confusing at times.
created_at: 2025-03-14T00:24:05Z
author_association: MEMBER
diff_hunk: @@ -63,85 +341,183 @@ Please follow these steps to set up Oppia Android on your local machine.
        5. Download the [google_checks.xml](https://github.com/checkstyle/checkstyle/blob/14005e371803bd52dff429904b354dc3e72638c0/src/main/resources/google_checks.xml) file. To do this, you can simply right-click on the download button at the top-right of the file.
        6. Copy this file to the directory where Git is installed (usually C:/Program Files/Git/).
 
-3. In Android Studio, select `File > Open`, navigate to `opensource/oppia-android/`, and click `OK` to load the project.
-
-4. Select the Compile JDK version
-   - Go to Android Studio > Settings > Build, Execution, Deployment > Build Tools > Gradle
-   - Under "**Gradle JDK**", select Android Studio Default JDK 11.
-   - Then, click "Apply" and "OK" to complete your setup.
-5. Click the elephant icon in the toolbar ("Sync Gradle") to ensure that all the correct dependencies are downloaded. (In general, you'll want to do this step any time you update your dependencies.)
-
 ## Run the app from Android Studio
path: wiki/Installing-Oppia-Android.md
user: login: BenHenning
body: Should this be 'opening the project'?
created_at: 2025-03-14T00:24:40Z
author_association: MEMBER
diff_hunk: @@ -63,85 +341,183 @@ Please follow these steps to set up Oppia Android on your local machine.
        5. Download the [google_checks.xml](https://github.com/checkstyle/checkstyle/blob/14005e371803bd52dff429904b354dc3e72638c0/src/main/resources/google_checks.xml) file. To do this, you can simply right-click on the download button at the top-right of the file.
        6. Copy this file to the directory where Git is installed (usually C:/Program Files/Git/).
 
-3. In Android Studio, select `File > Open`, navigate to `opensource/oppia-android/`, and click `OK` to load the project.
-
-4. Select the Compile JDK version
-   - Go to Android Studio > Settings > Build, Execution, Deployment > Build Tools > Gradle
-   - Under "**Gradle JDK**", select Android Studio Default JDK 11.
-   - Then, click "Apply" and "OK" to complete your setup.
-5. Click the elephant icon in the toolbar ("Sync Gradle") to ensure that all the correct dependencies are downloaded. (In general, you'll want to do this step any time you update your dependencies.)
-
 ## Run the app from Android Studio
 
-1. Go to Tools > AVD Manager, click "Create Virtual Device...". Then:
+1. Launch Android Studio, and on the welcome screen, select **Plugins** to install the Bazel for Android Studio plugin and restart Android Studio.
 
-   - Select a preferred device definition. In general, any device is fine, but you can use Pixel 3a as a default (if you're developing for phones) or Nexus 7 (if you're developing for tablets). After selecting a device, click "Next" at the bottom right to continue.
-   - Select a system image (in general, API Level 28, unless you're an M1 Mac user, in which case use API Level 29). Then click "Next".
-   - Click "Finish" to complete setup.
+2. On next open, click the options button next to the new project/open project to find the "Import Bazel Project" option.
 
-2. To run the app, select the emulator device you want from the dropdown menu to the left of the "Run" button in the toolbar.
+   <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/efcc4e6e-b6ba-44fc-9c96-aa381de83911" />
 
-3. Finally, click the "Run" button.
+3. A setup wizard will open. For Workspace, click (**...**) to open file manager and select `/opensource/oppia-android` as the location since this is where we have our project's `WORKSPACE` file.
+
+   ![Image](https://github.com/user-attachments/assets/9baf6f71-560b-49fe-84a7-c7b846a64287)
+
+4. On **OK**, you will be asked to **Trust project**. Accept because we trust the project.
+
+   <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/bfc91f6d-d809-418d-ab20-89d899f12f72" />
+
+5. On **next**, to Select Project View, **select Create from scratch**.
+
+   <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/cdc110d6-2926-4f96-b7d8-117e2c716f76" />
+
+6. A file similar to the one below will be generated:
+
+   <img width="760" alt="Image" src="https://github.com/user-attachments/assets/5a26210f-865d-4048-b5a5-73379984bfb5" />
+
+7. In the above file, modify it so that it looks like below(copy and paste):
path: wiki/Installing-Oppia-Android.md
user: login: BenHenning
body: ```suggestion
7. In the above file, modify it so that it looks like below (copy and paste):
```

Nit on spacing.
created_at: 2025-03-14T00:25:28Z
author_association: MEMBER
diff_hunk: @@ -63,85 +341,183 @@ Please follow these steps to set up Oppia Android on your local machine.
        5. Download the [google_checks.xml](https://github.com/checkstyle/checkstyle/blob/14005e371803bd52dff429904b354dc3e72638c0/src/main/resources/google_checks.xml) file. To do this, you can simply right-click on the download button at the top-right of the file.
        6. Copy this file to the directory where Git is installed (usually C:/Program Files/Git/).
 
-3. In Android Studio, select `File > Open`, navigate to `opensource/oppia-android/`, and click `OK` to load the project.
-
-4. Select the Compile JDK version
-   - Go to Android Studio > Settings > Build, Execution, Deployment > Build Tools > Gradle
-   - Under "**Gradle JDK**", select Android Studio Default JDK 11.
-   - Then, click "Apply" and "OK" to complete your setup.
-5. Click the elephant icon in the toolbar ("Sync Gradle") to ensure that all the correct dependencies are downloaded. (In general, you'll want to do this step any time you update your dependencies.)
-
 ## Run the app from Android Studio
 
-1. Go to Tools > AVD Manager, click "Create Virtual Device...". Then:
+1. Launch Android Studio, and on the welcome screen, select **Plugins** to install the Bazel for Android Studio plugin and restart Android Studio.
 
-   - Select a preferred device definition. In general, any device is fine, but you can use Pixel 3a as a default (if you're developing for phones) or Nexus 7 (if you're developing for tablets). After selecting a device, click "Next" at the bottom right to continue.
-   - Select a system image (in general, API Level 28, unless you're an M1 Mac user, in which case use API Level 29). Then click "Next".
-   - Click "Finish" to complete setup.
+2. On next open, click the options button next to the new project/open project to find the "Import Bazel Project" option.
 
-2. To run the app, select the emulator device you want from the dropdown menu to the left of the "Run" button in the toolbar.
+   <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/efcc4e6e-b6ba-44fc-9c96-aa381de83911" />
 
-3. Finally, click the "Run" button.
+3. A setup wizard will open. For Workspace, click (**...**) to open file manager and select `/opensource/oppia-android` as the location since this is where we have our project's `WORKSPACE` file.
+
+   ![Image](https://github.com/user-attachments/assets/9baf6f71-560b-49fe-84a7-c7b846a64287)
+
+4. On **OK**, you will be asked to **Trust project**. Accept because we trust the project.
+
+   <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/bfc91f6d-d809-418d-ab20-89d899f12f72" />
+
+5. On **next**, to Select Project View, **select Create from scratch**.
+
+   <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/cdc110d6-2926-4f96-b7d8-117e2c716f76" />
+
+6. A file similar to the one below will be generated:
+
+   <img width="760" alt="Image" src="https://github.com/user-attachments/assets/5a26210f-865d-4048-b5a5-73379984bfb5" />
+
+7. In the above file, modify it so that it looks like below(copy and paste):
+   
+   ```
+   directories:
+      # Add the directories you want added as source here
+      # By default, we've added your entire workspace ('.')
+      .
+      
+   # Automatically includes all relevant targets under the 'directories' above
+   derive_targets_from_directories: false
+   
+   targets:
+   # If source code isn't resolving, add additional targets that compile it here
+      //:oppia_dev_binary
+      //app
+      //app/src/main/...
+      //domain/...
+      //model/...
+      //testing/...
+      //utility/...
+      //data/...
+      //scripts/...
path: wiki/Installing-Oppia-Android.md
user: login: BenHenning
body: Probably too extensive. Let's do:

```
      //:oppia_dev_binary
      //app
      //app/src/main/...
      //domain/src/main/...
      //testing/src/main/...
      //utility/src/main/...
      //data/src/main/...
      //model/...
```

This drops scripts and all tests for a much faster sync.
created_at: 2025-03-14T00:26:54Z
author_association: MEMBER
diff_hunk: @@ -63,85 +341,183 @@ Please follow these steps to set up Oppia Android on your local machine.
        5. Download the [google_checks.xml](https://github.com/checkstyle/checkstyle/blob/14005e371803bd52dff429904b354dc3e72638c0/src/main/resources/google_checks.xml) file. To do this, you can simply right-click on the download button at the top-right of the file.
        6. Copy this file to the directory where Git is installed (usually C:/Program Files/Git/).
 
-3. In Android Studio, select `File > Open`, navigate to `opensource/oppia-android/`, and click `OK` to load the project.
-
-4. Select the Compile JDK version
-   - Go to Android Studio > Settings > Build, Execution, Deployment > Build Tools > Gradle
-   - Under "**Gradle JDK**", select Android Studio Default JDK 11.
-   - Then, click "Apply" and "OK" to complete your setup.
-5. Click the elephant icon in the toolbar ("Sync Gradle") to ensure that all the correct dependencies are downloaded. (In general, you'll want to do this step any time you update your dependencies.)
-
 ## Run the app from Android Studio
 
-1. Go to Tools > AVD Manager, click "Create Virtual Device...". Then:
+1. Launch Android Studio, and on the welcome screen, select **Plugins** to install the Bazel for Android Studio plugin and restart Android Studio.
 
-   - Select a preferred device definition. In general, any device is fine, but you can use Pixel 3a as a default (if you're developing for phones) or Nexus 7 (if you're developing for tablets). After selecting a device, click "Next" at the bottom right to continue.
-   - Select a system image (in general, API Level 28, unless you're an M1 Mac user, in which case use API Level 29). Then click "Next".
-   - Click "Finish" to complete setup.
+2. On next open, click the options button next to the new project/open project to find the "Import Bazel Project" option.
 
-2. To run the app, select the emulator device you want from the dropdown menu to the left of the "Run" button in the toolbar.
+   <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/efcc4e6e-b6ba-44fc-9c96-aa381de83911" />
 
-3. Finally, click the "Run" button.
+3. A setup wizard will open. For Workspace, click (**...**) to open file manager and select `/opensource/oppia-android` as the location since this is where we have our project's `WORKSPACE` file.
+
+   ![Image](https://github.com/user-attachments/assets/9baf6f71-560b-49fe-84a7-c7b846a64287)
+
+4. On **OK**, you will be asked to **Trust project**. Accept because we trust the project.
+
+   <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/bfc91f6d-d809-418d-ab20-89d899f12f72" />
+
+5. On **next**, to Select Project View, **select Create from scratch**.
+
+   <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/cdc110d6-2926-4f96-b7d8-117e2c716f76" />
+
+6. A file similar to the one below will be generated:
+
+   <img width="760" alt="Image" src="https://github.com/user-attachments/assets/5a26210f-865d-4048-b5a5-73379984bfb5" />
+
+7. In the above file, modify it so that it looks like below(copy and paste):
+   
+   ```
+   directories:
+      # Add the directories you want added as source here
+      # By default, we've added your entire workspace ('.')
+      .
+      
+   # Automatically includes all relevant targets under the 'directories' above
+   derive_targets_from_directories: false
+   
+   targets:
+   # If source code isn't resolving, add additional targets that compile it here
+      //:oppia_dev_binary
+      //app
+      //app/src/main/...
+      //domain/...
+      //model/...
+      //testing/...
+      //utility/...
+      //data/...
+      //scripts/...
+      
+   additional_languages:
+      # Uncomment any additional languages you want supported
+      # c
+      # dart
+      # kotlin
+      java
+      kotlin
+
+   # Please uncomment an android-SDK platform. Available SDKs are:
+      # android_sdk_platform: android-28
+      android_sdk_platform: android-29
path: wiki/Installing-Oppia-Android.md
user: login: BenHenning
body: Should be 30.
created_at: 2025-03-14T00:27:05Z
author_association: MEMBER
diff_hunk: @@ -63,85 +341,183 @@ Please follow these steps to set up Oppia Android on your local machine.
        5. Download the [google_checks.xml](https://github.com/checkstyle/checkstyle/blob/14005e371803bd52dff429904b354dc3e72638c0/src/main/resources/google_checks.xml) file. To do this, you can simply right-click on the download button at the top-right of the file.
        6. Copy this file to the directory where Git is installed (usually C:/Program Files/Git/).
 
-3. In Android Studio, select `File > Open`, navigate to `opensource/oppia-android/`, and click `OK` to load the project.
-
-4. Select the Compile JDK version
-   - Go to Android Studio > Settings > Build, Execution, Deployment > Build Tools > Gradle
-   - Under "**Gradle JDK**", select Android Studio Default JDK 11.
-   - Then, click "Apply" and "OK" to complete your setup.
-5. Click the elephant icon in the toolbar ("Sync Gradle") to ensure that all the correct dependencies are downloaded. (In general, you'll want to do this step any time you update your dependencies.)
-
 ## Run the app from Android Studio
 
-1. Go to Tools > AVD Manager, click "Create Virtual Device...". Then:
+1. Launch Android Studio, and on the welcome screen, select **Plugins** to install the Bazel for Android Studio plugin and restart Android Studio.
 
-   - Select a preferred device definition. In general, any device is fine, but you can use Pixel 3a as a default (if you're developing for phones) or Nexus 7 (if you're developing for tablets). After selecting a device, click "Next" at the bottom right to continue.
-   - Select a system image (in general, API Level 28, unless you're an M1 Mac user, in which case use API Level 29). Then click "Next".
-   - Click "Finish" to complete setup.
+2. On next open, click the options button next to the new project/open project to find the "Import Bazel Project" option.
 
-2. To run the app, select the emulator device you want from the dropdown menu to the left of the "Run" button in the toolbar.
+   <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/efcc4e6e-b6ba-44fc-9c96-aa381de83911" />
 
-3. Finally, click the "Run" button.
+3. A setup wizard will open. For Workspace, click (**...**) to open file manager and select `/opensource/oppia-android` as the location since this is where we have our project's `WORKSPACE` file.
+
+   ![Image](https://github.com/user-attachments/assets/9baf6f71-560b-49fe-84a7-c7b846a64287)
+
+4. On **OK**, you will be asked to **Trust project**. Accept because we trust the project.
+
+   <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/bfc91f6d-d809-418d-ab20-89d899f12f72" />
+
+5. On **next**, to Select Project View, **select Create from scratch**.
+
+   <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/cdc110d6-2926-4f96-b7d8-117e2c716f76" />
+
+6. A file similar to the one below will be generated:
+
+   <img width="760" alt="Image" src="https://github.com/user-attachments/assets/5a26210f-865d-4048-b5a5-73379984bfb5" />
+
+7. In the above file, modify it so that it looks like below(copy and paste):
+   
+   ```
+   directories:
+      # Add the directories you want added as source here
+      # By default, we've added your entire workspace ('.')
+      .
+      
+   # Automatically includes all relevant targets under the 'directories' above
+   derive_targets_from_directories: false
+   
+   targets:
+   # If source code isn't resolving, add additional targets that compile it here
+      //:oppia_dev_binary
+      //app
+      //app/src/main/...
+      //domain/...
+      //model/...
+      //testing/...
+      //utility/...
+      //data/...
+      //scripts/...
+      
+   additional_languages:
+      # Uncomment any additional languages you want supported
+      # c
+      # dart
+      # kotlin
+      java
+      kotlin
+
+   # Please uncomment an android-SDK platform. Available SDKs are:
+      # android_sdk_platform: android-28
+      android_sdk_platform: android-29
+      # android_sdk_platform: android-30
+      # android_sdk_platform: android-31
+      # android_sdk_platform: android-32
+      # android_sdk_platform: android-33
+      android_sdk_platform: android-34
+   
+   shard_sync: true
+   sync_flags:
+      --local_ram_resources=HOST_RAM*.5
+      --discard_analysis_cache
path: wiki/Installing-Oppia-Android.md
user: login: BenHenning
body: Drop this--it may be useful to bring back in the future, but I don't think it's needed with Bazel 6.x. Plus, discarding the analysis cache will really slow down even incremental syncs for less performant computers.
created_at: 2025-03-14T00:27:59Z
author_association: MEMBER
diff_hunk: @@ -63,85 +341,183 @@ Please follow these steps to set up Oppia Android on your local machine.
        5. Download the [google_checks.xml](https://github.com/checkstyle/checkstyle/blob/14005e371803bd52dff429904b354dc3e72638c0/src/main/resources/google_checks.xml) file. To do this, you can simply right-click on the download button at the top-right of the file.
        6. Copy this file to the directory where Git is installed (usually C:/Program Files/Git/).
 
-3. In Android Studio, select `File > Open`, navigate to `opensource/oppia-android/`, and click `OK` to load the project.
-
-4. Select the Compile JDK version
-   - Go to Android Studio > Settings > Build, Execution, Deployment > Build Tools > Gradle
-   - Under "**Gradle JDK**", select Android Studio Default JDK 11.
-   - Then, click "Apply" and "OK" to complete your setup.
-5. Click the elephant icon in the toolbar ("Sync Gradle") to ensure that all the correct dependencies are downloaded. (In general, you'll want to do this step any time you update your dependencies.)
-
 ## Run the app from Android Studio
 
-1. Go to Tools > AVD Manager, click "Create Virtual Device...". Then:
+1. Launch Android Studio, and on the welcome screen, select **Plugins** to install the Bazel for Android Studio plugin and restart Android Studio.
 
-   - Select a preferred device definition. In general, any device is fine, but you can use Pixel 3a as a default (if you're developing for phones) or Nexus 7 (if you're developing for tablets). After selecting a device, click "Next" at the bottom right to continue.
-   - Select a system image (in general, API Level 28, unless you're an M1 Mac user, in which case use API Level 29). Then click "Next".
-   - Click "Finish" to complete setup.
+2. On next open, click the options button next to the new project/open project to find the "Import Bazel Project" option.
 
-2. To run the app, select the emulator device you want from the dropdown menu to the left of the "Run" button in the toolbar.
+   <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/efcc4e6e-b6ba-44fc-9c96-aa381de83911" />
 
-3. Finally, click the "Run" button.
+3. A setup wizard will open. For Workspace, click (**...**) to open file manager and select `/opensource/oppia-android` as the location since this is where we have our project's `WORKSPACE` file.
+
+   ![Image](https://github.com/user-attachments/assets/9baf6f71-560b-49fe-84a7-c7b846a64287)
+
+4. On **OK**, you will be asked to **Trust project**. Accept because we trust the project.
+
+   <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/bfc91f6d-d809-418d-ab20-89d899f12f72" />
+
+5. On **next**, to Select Project View, **select Create from scratch**.
+
+   <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/cdc110d6-2926-4f96-b7d8-117e2c716f76" />
+
+6. A file similar to the one below will be generated:
+
+   <img width="760" alt="Image" src="https://github.com/user-attachments/assets/5a26210f-865d-4048-b5a5-73379984bfb5" />
+
+7. In the above file, modify it so that it looks like below(copy and paste):
+   
+   ```
+   directories:
+      # Add the directories you want added as source here
+      # By default, we've added your entire workspace ('.')
+      .
+      
+   # Automatically includes all relevant targets under the 'directories' above
+   derive_targets_from_directories: false
+   
+   targets:
+   # If source code isn't resolving, add additional targets that compile it here
+      //:oppia_dev_binary
+      //app
+      //app/src/main/...
+      //domain/...
+      //model/...
+      //testing/...
+      //utility/...
+      //data/...
+      //scripts/...
+      
+   additional_languages:
+      # Uncomment any additional languages you want supported
+      # c
+      # dart
+      # kotlin
+      java
+      kotlin
+
+   # Please uncomment an android-SDK platform. Available SDKs are:
+      # android_sdk_platform: android-28
+      android_sdk_platform: android-29
+      # android_sdk_platform: android-30
+      # android_sdk_platform: android-31
+      # android_sdk_platform: android-32
+      # android_sdk_platform: android-33
+      android_sdk_platform: android-34
+   
+   shard_sync: true
+   sync_flags:
+      --local_ram_resources=HOST_RAM*.5
+      --discard_analysis_cache
+   
+   java_language_level: 11
+   ```
+   **Note**: Only enable Android-SDK platforms that you have installed per the [Prepare developer environment](#prepare-developer-environment) section above. Android-SDK platforms are useful for creating emulators to test your app with.
+
+8. Click **Create**, and allow the project to synchronize.
+
+9. Once sync has finished, you can now build and install the app on either a virtual or physical device. Bazel supports deploying to only one device at a time, so you can connect one device, or launch one emulator at a time.
+
+   You can run the project by using the Bazel plugin to set up run configurations for the target that you wish to build. This performs the same action as the commands below, but using the GUI to run the app might be more intuitive for some developers.
path: wiki/Installing-Oppia-Android.md
user: login: BenHenning
body: FWIW we can actually save these configurations for people to use, too:

https://ij.bazel.build/docs/run-configurations.html#sharing-run-configurations

Perhaps that's worth doing and updating the project view above to import it?
created_at: 2025-03-14T00:29:17Z
author_association: MEMBER
diff_hunk: @@ -63,85 +341,183 @@ Please follow these steps to set up Oppia Android on your local machine.
        5. Download the [google_checks.xml](https://github.com/checkstyle/checkstyle/blob/14005e371803bd52dff429904b354dc3e72638c0/src/main/resources/google_checks.xml) file. To do this, you can simply right-click on the download button at the top-right of the file.
        6. Copy this file to the directory where Git is installed (usually C:/Program Files/Git/).
 
-3. In Android Studio, select `File > Open`, navigate to `opensource/oppia-android/`, and click `OK` to load the project.
-
-4. Select the Compile JDK version
-   - Go to Android Studio > Settings > Build, Execution, Deployment > Build Tools > Gradle
-   - Under "**Gradle JDK**", select Android Studio Default JDK 11.
-   - Then, click "Apply" and "OK" to complete your setup.
-5. Click the elephant icon in the toolbar ("Sync Gradle") to ensure that all the correct dependencies are downloaded. (In general, you'll want to do this step any time you update your dependencies.)
-
 ## Run the app from Android Studio
 
-1. Go to Tools > AVD Manager, click "Create Virtual Device...". Then:
+1. Launch Android Studio, and on the welcome screen, select **Plugins** to install the Bazel for Android Studio plugin and restart Android Studio.
 
-   - Select a preferred device definition. In general, any device is fine, but you can use Pixel 3a as a default (if you're developing for phones) or Nexus 7 (if you're developing for tablets). After selecting a device, click "Next" at the bottom right to continue.
-   - Select a system image (in general, API Level 28, unless you're an M1 Mac user, in which case use API Level 29). Then click "Next".
-   - Click "Finish" to complete setup.
+2. On next open, click the options button next to the new project/open project to find the "Import Bazel Project" option.
 
-2. To run the app, select the emulator device you want from the dropdown menu to the left of the "Run" button in the toolbar.
+   <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/efcc4e6e-b6ba-44fc-9c96-aa381de83911" />
 
-3. Finally, click the "Run" button.
+3. A setup wizard will open. For Workspace, click (**...**) to open file manager and select `/opensource/oppia-android` as the location since this is where we have our project's `WORKSPACE` file.
+
+   ![Image](https://github.com/user-attachments/assets/9baf6f71-560b-49fe-84a7-c7b846a64287)
+
+4. On **OK**, you will be asked to **Trust project**. Accept because we trust the project.
+
+   <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/bfc91f6d-d809-418d-ab20-89d899f12f72" />
+
+5. On **next**, to Select Project View, **select Create from scratch**.
+
+   <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/cdc110d6-2926-4f96-b7d8-117e2c716f76" />
+
+6. A file similar to the one below will be generated:
+
+   <img width="760" alt="Image" src="https://github.com/user-attachments/assets/5a26210f-865d-4048-b5a5-73379984bfb5" />
+
+7. In the above file, modify it so that it looks like below(copy and paste):
+   
+   ```
+   directories:
+      # Add the directories you want added as source here
+      # By default, we've added your entire workspace ('.')
+      .
+      
+   # Automatically includes all relevant targets under the 'directories' above
+   derive_targets_from_directories: false
+   
+   targets:
+   # If source code isn't resolving, add additional targets that compile it here
+      //:oppia_dev_binary
+      //app
+      //app/src/main/...
+      //domain/...
+      //model/...
+      //testing/...
+      //utility/...
+      //data/...
+      //scripts/...
+      
+   additional_languages:
+      # Uncomment any additional languages you want supported
+      # c
+      # dart
+      # kotlin
+      java
+      kotlin
+
+   # Please uncomment an android-SDK platform. Available SDKs are:
+      # android_sdk_platform: android-28
+      android_sdk_platform: android-29
+      # android_sdk_platform: android-30
+      # android_sdk_platform: android-31
+      # android_sdk_platform: android-32
+      # android_sdk_platform: android-33
+      android_sdk_platform: android-34
+   
+   shard_sync: true
+   sync_flags:
+      --local_ram_resources=HOST_RAM*.5
+      --discard_analysis_cache
+   
+   java_language_level: 11
+   ```
+   **Note**: Only enable Android-SDK platforms that you have installed per the [Prepare developer environment](#prepare-developer-environment) section above. Android-SDK platforms are useful for creating emulators to test your app with.
+
+8. Click **Create**, and allow the project to synchronize.
+
+9. Once sync has finished, you can now build and install the app on either a virtual or physical device. Bazel supports deploying to only one device at a time, so you can connect one device, or launch one emulator at a time.
+
+   You can run the project by using the Bazel plugin to set up run configurations for the target that you wish to build. This performs the same action as the commands below, but using the GUI to run the app might be more intuitive for some developers.
+
+   ![Screenshot 2025-02-26 at 22 16 32](https://github.com/user-attachments/assets/f3be5288-dc96-4079-bcb2-b514de81f899)
+
+   Edit configurations allows us to specify the run command:
+
+   ![Image](https://github.com/user-attachments/assets/7270b6b3-11ac-4b49-a39a-734e0437bb9e)
+
+     - Target **Name**, is helpful for identifying the target from the list on the left.
+     - **Target expression** requires a build target such as `//:oppia_dev_binary`.
+     - **The Bazel command** is `mobile-install`
+     - **Bazel flags** are optional.
+     - Select **Apply** and then **Close** or **Ok**.
+
+## Run the app from the command line
path: wiki/Installing-Oppia-Android.md
user: login: BenHenning
body: As mentioned in another comment, but perhaps this should go in the user guide and this updated to point to that?

In fact, I wonder if a lot of the "here's important Bazel stuff you need to do often or understand" should go in the user guide as a basis, and this page can be kept more for setting everything up.
created_at: 2025-03-14T00:30:16Z
author_association: MEMBER
diff_hunk: @@ -63,85 +341,183 @@ Please follow these steps to set up Oppia Android on your local machine.
        5. Download the [google_checks.xml](https://github.com/checkstyle/checkstyle/blob/14005e371803bd52dff429904b354dc3e72638c0/src/main/resources/google_checks.xml) file. To do this, you can simply right-click on the download button at the top-right of the file.
        6. Copy this file to the directory where Git is installed (usually C:/Program Files/Git/).
 
-3. In Android Studio, select `File > Open`, navigate to `opensource/oppia-android/`, and click `OK` to load the project.
-
-4. Select the Compile JDK version
-   - Go to Android Studio > Settings > Build, Execution, Deployment > Build Tools > Gradle
-   - Under "**Gradle JDK**", select Android Studio Default JDK 11.
-   - Then, click "Apply" and "OK" to complete your setup.
-5. Click the elephant icon in the toolbar ("Sync Gradle") to ensure that all the correct dependencies are downloaded. (In general, you'll want to do this step any time you update your dependencies.)
-
 ## Run the app from Android Studio
 
-1. Go to Tools > AVD Manager, click "Create Virtual Device...". Then:
+1. Launch Android Studio, and on the welcome screen, select **Plugins** to install the Bazel for Android Studio plugin and restart Android Studio.
 
-   - Select a preferred device definition. In general, any device is fine, but you can use Pixel 3a as a default (if you're developing for phones) or Nexus 7 (if you're developing for tablets). After selecting a device, click "Next" at the bottom right to continue.
-   - Select a system image (in general, API Level 28, unless you're an M1 Mac user, in which case use API Level 29). Then click "Next".
-   - Click "Finish" to complete setup.
+2. On next open, click the options button next to the new project/open project to find the "Import Bazel Project" option.
 
-2. To run the app, select the emulator device you want from the dropdown menu to the left of the "Run" button in the toolbar.
+   <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/efcc4e6e-b6ba-44fc-9c96-aa381de83911" />
 
-3. Finally, click the "Run" button.
+3. A setup wizard will open. For Workspace, click (**...**) to open file manager and select `/opensource/oppia-android` as the location since this is where we have our project's `WORKSPACE` file.
+
+   ![Image](https://github.com/user-attachments/assets/9baf6f71-560b-49fe-84a7-c7b846a64287)
+
+4. On **OK**, you will be asked to **Trust project**. Accept because we trust the project.
+
+   <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/bfc91f6d-d809-418d-ab20-89d899f12f72" />
+
+5. On **next**, to Select Project View, **select Create from scratch**.
+
+   <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/cdc110d6-2926-4f96-b7d8-117e2c716f76" />
+
+6. A file similar to the one below will be generated:
+
+   <img width="760" alt="Image" src="https://github.com/user-attachments/assets/5a26210f-865d-4048-b5a5-73379984bfb5" />
+
+7. In the above file, modify it so that it looks like below(copy and paste):
+   
+   ```
+   directories:
+      # Add the directories you want added as source here
+      # By default, we've added your entire workspace ('.')
+      .
+      
+   # Automatically includes all relevant targets under the 'directories' above
+   derive_targets_from_directories: false
+   
+   targets:
+   # If source code isn't resolving, add additional targets that compile it here
+      //:oppia_dev_binary
+      //app
+      //app/src/main/...
+      //domain/...
+      //model/...
+      //testing/...
+      //utility/...
+      //data/...
+      //scripts/...
+      
+   additional_languages:
+      # Uncomment any additional languages you want supported
+      # c
+      # dart
+      # kotlin
+      java
+      kotlin
+
+   # Please uncomment an android-SDK platform. Available SDKs are:
+      # android_sdk_platform: android-28
+      android_sdk_platform: android-29
+      # android_sdk_platform: android-30
+      # android_sdk_platform: android-31
+      # android_sdk_platform: android-32
+      # android_sdk_platform: android-33
+      android_sdk_platform: android-34
+   
+   shard_sync: true
+   sync_flags:
+      --local_ram_resources=HOST_RAM*.5
+      --discard_analysis_cache
+   
+   java_language_level: 11
+   ```
+   **Note**: Only enable Android-SDK platforms that you have installed per the [Prepare developer environment](#prepare-developer-environment) section above. Android-SDK platforms are useful for creating emulators to test your app with.
+
+8. Click **Create**, and allow the project to synchronize.
+
+9. Once sync has finished, you can now build and install the app on either a virtual or physical device. Bazel supports deploying to only one device at a time, so you can connect one device, or launch one emulator at a time.
+
+   You can run the project by using the Bazel plugin to set up run configurations for the target that you wish to build. This performs the same action as the commands below, but using the GUI to run the app might be more intuitive for some developers.
+
+   ![Screenshot 2025-02-26 at 22 16 32](https://github.com/user-attachments/assets/f3be5288-dc96-4079-bcb2-b514de81f899)
+
+   Edit configurations allows us to specify the run command:
+
+   ![Image](https://github.com/user-attachments/assets/7270b6b3-11ac-4b49-a39a-734e0437bb9e)
+
+     - Target **Name**, is helpful for identifying the target from the list on the left.
+     - **Target expression** requires a build target such as `//:oppia_dev_binary`.
+     - **The Bazel command** is `mobile-install`
+     - **Bazel flags** are optional.
+     - Select **Apply** and then **Close** or **Ok**.
+
+## Run the app from the command line
+
+Using the command line is helpful in instances when you need to run some targets outside of Android Studio.
+
+Run the following commands in your terminal. All Bazel commands must be run from the root of the ‘oppia-android’ directory otherwise they will fail.
+
+Note that on the first run, these commands may take 10-20 minutes to complete depending on the performance of your machine. Subsequent runs will be much faster.
+
+On Sdk 29 and below, run:
+   ```
+   bazel mobile-install //:oppia_dev_binary
+   ```
+This will build, install and launch the app on your device.
+
+On Sdk 30 and newer, run:
+   ```
+   bazel build //:oppia_dev
+   ```
+followed by:
+   ```
+   adb install bazel-bin/oppia_dev_binary.apk  
+   ```
+Starting from Sdk 30, incremental builds, like those executed using `bazel mobile-install`, are no longer permitted, necessitating the use of two separate commands.
+
+If everything is working, you should see output like the following:
+
+```
+Target //:oppia_dev up-to-date:
+  bazel-bin/oppia_dev.aab
+INFO: Elapsed time: ...
+INFO: 1 process...
+INFO: Build completed successfully, ...
+```
+
+Note also that the ``oppia_dev.aab`` under the ``bazel-bin`` directory of your local copy of Oppia Android should be a fully functioning development version of the app that can be installed using bundle-tool. However, it's recommended to deploy Oppia to an emulator or connected device using the `mobile-install` command.
 
 ## Set up and run tests
 Testing the app is an integral part of our development process. You will need to test all code changes to ensure that the app works correctly, therefore it is important to ensure that your test configuration works.
 
-We strongly recommend running tests on Robolectric which is faster because it does not require a physical device or emulator setup.
+Our Bazel setup currently supports running tests on Robolectric which is fast because it does not require a physical device or emulator setup.
 
-### Configure Robolectric Tests
+We can run tests either through the UI supported by the Bazel Plugin, or via running a `bazel test` command on the terminal, i.e.:
 
-#### Step-by-Step guidance for setting up and running app modules robolectric test:
+> Tip 1: In order to get the correct path always, open the test file, then on the AS sidebar, right click on the file, and select `copy path/reference`. Then select `copy path from repository root`. Paste the copied path to terminal and remove the `.kt` extension.
 
-1. Go to **Edit Configuration** in Android Studio (Bumblebee | 2021.1.1 Patch 3)
-   ![](https://user-images.githubusercontent.com/9396084/79109714-83525980-7d96-11ea-99d7-f83ea81a8a50.png)
+   ```
+   bazel test full-path-of-test-file
+   ```
 
-2. Click on Add(+) -> **JUnit**
-   ![](https://github.com/oppia/oppia-android/assets/76530270/87caf3fc-37d9-472d-92fd-b8ec49fb6b49)
+e.g.
+   
+   ```
+   bazel test domain/src/test/java/org/oppia/android/domain/onboarding/AppStartupStateControllerTest
+   ```
 
-3. Enter following information:
-   - a) Name of test. Example: In my case "SplashActivityTest"
-   - b) Make sure select "java 11" and oppia-android.app
-   - c) Class path of Test class. Example: In my case "org.oppia.android.app.splash.
-   SplashActivityTest"
-   - d) Press `OK` to select the test.
-   ![](https://github.com/oppia/oppia-android/assets/76530270/5901624a-df76-4b27-8f31-6077a68fcb89)
+> Tip 2: You can pass a target argument to the `bazel test` command instead. Copy the relative path to the test file and query its target using `bazel query path-of-test-file` e.g. `bazel query domain/src/test/java/org/oppia/android/domain/onboarding/AppStartupStateControllerTest.kt`. This will give you a Bazel target (i.e. starts with '//') --just copy that and remove the `.kt` at the end and you can pass it to `bazel test`, e.g.
 
-4. Click on "Run" button to run robolectric test. (In my case "SplashActivityTest")
-   ![](https://github.com/oppia/oppia-android/assets/76530270/75a6b998-90c5-4f0a-8886-78f96970be90)
+```
+bazel test //domain/src/test/java/org/oppia/android/domain/onboarding:AppStartupStateControllerTest
+```
 
-#### For tests that are in non-app modules, such as **domain** or **utility**::
+### Configure Robolectric Tests
path: wiki/Installing-Oppia-Android.md
user: login: BenHenning
body: Probably also better to put in the user guide?
created_at: 2025-03-14T00:30:46Z
author_association: MEMBER
diff_hunk: @@ -63,85 +341,183 @@ Please follow these steps to set up Oppia Android on your local machine.
        5. Download the [google_checks.xml](https://github.com/checkstyle/checkstyle/blob/14005e371803bd52dff429904b354dc3e72638c0/src/main/resources/google_checks.xml) file. To do this, you can simply right-click on the download button at the top-right of the file.
        6. Copy this file to the directory where Git is installed (usually C:/Program Files/Git/).
 
-3. In Android Studio, select `File > Open`, navigate to `opensource/oppia-android/`, and click `OK` to load the project.
-
-4. Select the Compile JDK version
-   - Go to Android Studio > Settings > Build, Execution, Deployment > Build Tools > Gradle
-   - Under "**Gradle JDK**", select Android Studio Default JDK 11.
-   - Then, click "Apply" and "OK" to complete your setup.
-5. Click the elephant icon in the toolbar ("Sync Gradle") to ensure that all the correct dependencies are downloaded. (In general, you'll want to do this step any time you update your dependencies.)
-
 ## Run the app from Android Studio
 
-1. Go to Tools > AVD Manager, click "Create Virtual Device...". Then:
+1. Launch Android Studio, and on the welcome screen, select **Plugins** to install the Bazel for Android Studio plugin and restart Android Studio.
 
-   - Select a preferred device definition. In general, any device is fine, but you can use Pixel 3a as a default (if you're developing for phones) or Nexus 7 (if you're developing for tablets). After selecting a device, click "Next" at the bottom right to continue.
-   - Select a system image (in general, API Level 28, unless you're an M1 Mac user, in which case use API Level 29). Then click "Next".
-   - Click "Finish" to complete setup.
+2. On next open, click the options button next to the new project/open project to find the "Import Bazel Project" option.
 
-2. To run the app, select the emulator device you want from the dropdown menu to the left of the "Run" button in the toolbar.
+   <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/efcc4e6e-b6ba-44fc-9c96-aa381de83911" />
 
-3. Finally, click the "Run" button.
+3. A setup wizard will open. For Workspace, click (**...**) to open file manager and select `/opensource/oppia-android` as the location since this is where we have our project's `WORKSPACE` file.
+
+   ![Image](https://github.com/user-attachments/assets/9baf6f71-560b-49fe-84a7-c7b846a64287)
+
+4. On **OK**, you will be asked to **Trust project**. Accept because we trust the project.
+
+   <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/bfc91f6d-d809-418d-ab20-89d899f12f72" />
+
+5. On **next**, to Select Project View, **select Create from scratch**.
+
+   <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/cdc110d6-2926-4f96-b7d8-117e2c716f76" />
+
+6. A file similar to the one below will be generated:
+
+   <img width="760" alt="Image" src="https://github.com/user-attachments/assets/5a26210f-865d-4048-b5a5-73379984bfb5" />
+
+7. In the above file, modify it so that it looks like below(copy and paste):
+   
+   ```
+   directories:
+      # Add the directories you want added as source here
+      # By default, we've added your entire workspace ('.')
+      .
+      
+   # Automatically includes all relevant targets under the 'directories' above
+   derive_targets_from_directories: false
+   
+   targets:
+   # If source code isn't resolving, add additional targets that compile it here
+      //:oppia_dev_binary
+      //app
+      //app/src/main/...
+      //domain/...
+      //model/...
+      //testing/...
+      //utility/...
+      //data/...
+      //scripts/...
+      
+   additional_languages:
+      # Uncomment any additional languages you want supported
+      # c
+      # dart
+      # kotlin
+      java
+      kotlin
+
+   # Please uncomment an android-SDK platform. Available SDKs are:
+      # android_sdk_platform: android-28
+      android_sdk_platform: android-29
+      # android_sdk_platform: android-30
+      # android_sdk_platform: android-31
+      # android_sdk_platform: android-32
+      # android_sdk_platform: android-33
+      android_sdk_platform: android-34
+   
+   shard_sync: true
+   sync_flags:
+      --local_ram_resources=HOST_RAM*.5
+      --discard_analysis_cache
+   
+   java_language_level: 11
+   ```
+   **Note**: Only enable Android-SDK platforms that you have installed per the [Prepare developer environment](#prepare-developer-environment) section above. Android-SDK platforms are useful for creating emulators to test your app with.
+
+8. Click **Create**, and allow the project to synchronize.
+
+9. Once sync has finished, you can now build and install the app on either a virtual or physical device. Bazel supports deploying to only one device at a time, so you can connect one device, or launch one emulator at a time.
+
+   You can run the project by using the Bazel plugin to set up run configurations for the target that you wish to build. This performs the same action as the commands below, but using the GUI to run the app might be more intuitive for some developers.
+
+   ![Screenshot 2025-02-26 at 22 16 32](https://github.com/user-attachments/assets/f3be5288-dc96-4079-bcb2-b514de81f899)
+
+   Edit configurations allows us to specify the run command:
+
+   ![Image](https://github.com/user-attachments/assets/7270b6b3-11ac-4b49-a39a-734e0437bb9e)
+
+     - Target **Name**, is helpful for identifying the target from the list on the left.
+     - **Target expression** requires a build target such as `//:oppia_dev_binary`.
+     - **The Bazel command** is `mobile-install`
+     - **Bazel flags** are optional.
+     - Select **Apply** and then **Close** or **Ok**.
+
+## Run the app from the command line
+
+Using the command line is helpful in instances when you need to run some targets outside of Android Studio.
+
+Run the following commands in your terminal. All Bazel commands must be run from the root of the ‘oppia-android’ directory otherwise they will fail.
+
+Note that on the first run, these commands may take 10-20 minutes to complete depending on the performance of your machine. Subsequent runs will be much faster.
+
+On Sdk 29 and below, run:
+   ```
+   bazel mobile-install //:oppia_dev_binary
+   ```
+This will build, install and launch the app on your device.
+
+On Sdk 30 and newer, run:
+   ```
+   bazel build //:oppia_dev
+   ```
+followed by:
+   ```
+   adb install bazel-bin/oppia_dev_binary.apk  
+   ```
+Starting from Sdk 30, incremental builds, like those executed using `bazel mobile-install`, are no longer permitted, necessitating the use of two separate commands.
+
+If everything is working, you should see output like the following:
+
+```
+Target //:oppia_dev up-to-date:
+  bazel-bin/oppia_dev.aab
+INFO: Elapsed time: ...
+INFO: 1 process...
+INFO: Build completed successfully, ...
+```
+
+Note also that the ``oppia_dev.aab`` under the ``bazel-bin`` directory of your local copy of Oppia Android should be a fully functioning development version of the app that can be installed using bundle-tool. However, it's recommended to deploy Oppia to an emulator or connected device using the `mobile-install` command.
 
 ## Set up and run tests
 Testing the app is an integral part of our development process. You will need to test all code changes to ensure that the app works correctly, therefore it is important to ensure that your test configuration works.
 
-We strongly recommend running tests on Robolectric which is faster because it does not require a physical device or emulator setup.
+Our Bazel setup currently supports running tests on Robolectric which is fast because it does not require a physical device or emulator setup.
 
-### Configure Robolectric Tests
+We can run tests either through the UI supported by the Bazel Plugin, or via running a `bazel test` command on the terminal, i.e.:
 
-#### Step-by-Step guidance for setting up and running app modules robolectric test:
+> Tip 1: In order to get the correct path always, open the test file, then on the AS sidebar, right click on the file, and select `copy path/reference`. Then select `copy path from repository root`. Paste the copied path to terminal and remove the `.kt` extension.
 
-1. Go to **Edit Configuration** in Android Studio (Bumblebee | 2021.1.1 Patch 3)
-   ![](https://user-images.githubusercontent.com/9396084/79109714-83525980-7d96-11ea-99d7-f83ea81a8a50.png)
+   ```
+   bazel test full-path-of-test-file
+   ```
 
-2. Click on Add(+) -> **JUnit**
-   ![](https://github.com/oppia/oppia-android/assets/76530270/87caf3fc-37d9-472d-92fd-b8ec49fb6b49)
+e.g.
+   
+   ```
+   bazel test domain/src/test/java/org/oppia/android/domain/onboarding/AppStartupStateControllerTest
+   ```
 
-3. Enter following information:
-   - a) Name of test. Example: In my case "SplashActivityTest"
-   - b) Make sure select "java 11" and oppia-android.app
-   - c) Class path of Test class. Example: In my case "org.oppia.android.app.splash.
-   SplashActivityTest"
-   - d) Press `OK` to select the test.
-   ![](https://github.com/oppia/oppia-android/assets/76530270/5901624a-df76-4b27-8f31-6077a68fcb89)
+> Tip 2: You can pass a target argument to the `bazel test` command instead. Copy the relative path to the test file and query its target using `bazel query path-of-test-file` e.g. `bazel query domain/src/test/java/org/oppia/android/domain/onboarding/AppStartupStateControllerTest.kt`. This will give you a Bazel target (i.e. starts with '//') --just copy that and remove the `.kt` at the end and you can pass it to `bazel test`, e.g.
 
-4. Click on "Run" button to run robolectric test. (In my case "SplashActivityTest")
-   ![](https://github.com/oppia/oppia-android/assets/76530270/75a6b998-90c5-4f0a-8886-78f96970be90)
+```
+bazel test //domain/src/test/java/org/oppia/android/domain/onboarding:AppStartupStateControllerTest
+```
 
-#### For tests that are in non-app modules, such as **domain** or **utility**::
+### Configure Robolectric Tests
+
+#### Step-by-Step guidance for setting up and running app module robolectric tests:
 
-1. In Android Studio, open the desired test file, e.g., `AnalyticsControllerTest`.
-2. In the test file, to the left of the class name, click on the orange and green arrow, and select **Run 'AnalyticsControllerTest'**.
-   - You will notice that the emulator is greyed out, but the run window will open to show the running tests:
-   ![](https://user-images.githubusercontent.com/59600948/272657015-158117e5-47d2-40fc-a38b-5dee6c347556.png)
+1. In Android Studio, open the test file that you wish to run. If sync completed successfully when the project was opened, there will be a green run arrow next to the class name, as well as next to each individual test name. Clicking on the arrow will run either the full class or a single test as selected.
 
-### Configure Emulator Tests
+2. Because we have set up the Bazel plugin, we can also run a test class using the run arrow at the top of the project window:
 
-**Espresso is slower for running tests, so we recommend using Robolectric.**
+   ![Screenshot 2025-02-26 at 22 16 32](https://github.com/user-attachments/assets/f3be5288-dc96-4079-bcb2-b514de81f899)
 
-1. In Android Studio, open the desired test file, e.g., `HomeActivityTest`.
-2. In the Android Studio toolbar, click on the `Available Devices` option. Select an emulator that has between API 28-30.
+   Edit configurations allows us to specify the run command:
+   ![Screenshot 2025-02-26 at 22 19 34](https://github.com/user-attachments/assets/462d07d2-4407-4898-bbc4-544509bd7486)
 
-   **Note**: If you don't have any available devices in this list, please follow [these instructions](#run-the-app-from-android-studio) to create one.
+   - Test **name**, is helpful for identifying the test target from the list on the left.
+   - **Target expression** requires the fully qualified path to the test file.
+   - **The Bazel command** for running tests is `test`
+   - **Bazel flags** are optional.
+   - Select **Apply** and then **Close** or **Ok**.
 
-3. In the test file, to the left of the class name, click on the orange and green arrow, and select **Run 'HomeActivityTest'**.
-   ![](https://user-images.githubusercontent.com/59600948/272657131-96e5354b-13a9-4709-969a-b9494a65c30f.png)
+#### For tests that are in non-app modules, such as **domain** or **utility**::
path: wiki/Installing-Oppia-Android.md
user: login: BenHenning
body: Others:
- Can right click on the tab if the test is open and copy the BUILD target.
- For all tests (including app), you can run 'bazel query' on the relative source path of the file (also copyable via right click on the file tab when the test is open) and remove the '.kt' at the end of the returned value to get the test target.
created_at: 2025-03-14T00:32:08Z
author_association: MEMBER
diff_hunk: @@ -150,8 +526,95 @@ We strongly recommend running tests on Robolectric which is faster because it do
 
 - To learn about how we write tests at oppia-android, please refer to: [Oppia Android Testing](https://github.com/oppia/oppia-android/wiki/Oppia-Android-Testing).
 
-- To get started with Bazel, please see [Oppia-Bazel-Setup-Instructions](https://github.com/oppia/oppia-android/wiki/Oppia-Bazel-Setup-Instructions) and follow the instructions appropriate to your OS.
-
-- If you run into any issues during your setup, search our [discussions](https://github.com/oppia/oppia-android/discussions) forum or start a new discussion.
-
-- Please see  [Troubleshooting-Installation](https://github.com/oppia/oppia-android/wiki/Troubleshooting-Installation) for solutions to some common setup issues.
+- To learn more about getting started with Bazel, please see [Oppia-Bazel-Glossary](https://github.com/oppia/oppia-android/wiki/Oppia-Bazel-Glossary).
+
+### Troubleshooting Installation
+#### General issues
+1. If the Static Checks on your PR keeps failing, please refer to [instructions on running static checks locally](https://github.com/oppia/oppia-android/wiki/Static-Analysis-Checks#how-to-run-static-checks-locally) in order to catch these errors before pushing.
+2. If you are using Android Studio or another UI-based git to push, you might see unclear errors such as `Error: Failed to push some refs to git@github.com:<your_user_name>/oppia-android.git`. We recommend using the command line to run all git commands.
+
+#### Bazel issues
+The team is in the process of migrating away from Gradle to Bazel, so while the project still has Gradle build files, they are no longer maintained and cannot be used to build the project.
+
+Please note that:
+- It's currently recommended that all team members use **Bazel** for their active development in Android Studio. While some team members use the Bazel Android Studio plugin, day-to-day Bazel development currently suffers from:
path: wiki/Installing-Oppia-Android.md
user: login: BenHenning
body: ```suggestion
- The IntelliJ Bazel plugin currently has some known issues:
```
created_at: 2025-03-14T00:32:55Z
author_association: MEMBER
diff_hunk: @@ -150,8 +526,95 @@ We strongly recommend running tests on Robolectric which is faster because it do
 
 - To learn about how we write tests at oppia-android, please refer to: [Oppia Android Testing](https://github.com/oppia/oppia-android/wiki/Oppia-Android-Testing).
 
-- To get started with Bazel, please see [Oppia-Bazel-Setup-Instructions](https://github.com/oppia/oppia-android/wiki/Oppia-Bazel-Setup-Instructions) and follow the instructions appropriate to your OS.
-
-- If you run into any issues during your setup, search our [discussions](https://github.com/oppia/oppia-android/discussions) forum or start a new discussion.
-
-- Please see  [Troubleshooting-Installation](https://github.com/oppia/oppia-android/wiki/Troubleshooting-Installation) for solutions to some common setup issues.
+- To learn more about getting started with Bazel, please see [Oppia-Bazel-Glossary](https://github.com/oppia/oppia-android/wiki/Oppia-Bazel-Glossary).
+
+### Troubleshooting Installation
+#### General issues
+1. If the Static Checks on your PR keeps failing, please refer to [instructions on running static checks locally](https://github.com/oppia/oppia-android/wiki/Static-Analysis-Checks#how-to-run-static-checks-locally) in order to catch these errors before pushing.
+2. If you are using Android Studio or another UI-based git to push, you might see unclear errors such as `Error: Failed to push some refs to git@github.com:<your_user_name>/oppia-android.git`. We recommend using the command line to run all git commands.
+
+#### Bazel issues
+The team is in the process of migrating away from Gradle to Bazel, so while the project still has Gradle build files, they are no longer maintained and cannot be used to build the project.
+
+Please note that:
+- It's currently recommended that all team members use **Bazel** for their active development in Android Studio. While some team members use the Bazel Android Studio plugin, day-to-day Bazel development currently suffers from:
+    - Significant memory overhead that continues to grow without careful pruning (i.e. periodic shutdowns of the local Bazel build server). On some Linux distros or MacOS, this can result in a Kernel panic when memory is fully exhausted.
+    - Various symbolic errors throughout the codebase that can make it much more difficult to jump to specific symbols (though, unlike Gradle, all code including scripts are editable and runnable within Android Studio).
+    - Syntax highlighting errors in some instances.
+- As the team finishes the migration to Bazel, communications and instructions will be sent ahead of time, and we will continually update our documentation with the latest changes.
+
+1. No matching toolchains (sdk_toolchain_type)
path: wiki/Installing-Oppia-Android.md
user: login: BenHenning
body: ```suggestion

Other problems that you may run into:

1. No matching toolchains (sdk_toolchain_type)
```

(to provide some spacing between the 'please note that' and the numeration of problems).
created_at: 2025-03-14T00:33:42Z
author_association: MEMBER
diff_hunk: @@ -1,33 +0,0 @@
-## Table of Contents
path: wiki/Frequent-Errors-and-Solutions.md
user: login: adhiamboperes
body: I felt that the tablet layout error was pretty specific and not necessarily a frequently encountered error. However, I have moved it to the new errors section. The other errors are covered too.
created_at: 2025-03-14T09:14:32Z
author_association: CONTRIBUTOR
diff_hunk: @@ -3,60 +3,53 @@
 - [Overview](#overview)
path: wiki/Oppia-Bazel-Glossary.md
user: login: adhiamboperes
body: Thanks - I was not sure about that naming either.
created_at: 2025-03-14T09:18:41Z
author_association: CONTRIBUTOR
diff_hunk: @@ -1,128 +0,0 @@
-Here are some general troubleshooting tips for oppia-android. The specific platforms are Linux, Windows and Mac OS.
-
-## Table of Contents
-
-- [General issues](#general-issues)
-- [Bazel issues](#bazel-issues)
-- [Can’t find a particular issue?](#cant-find-a-particular-issue)
-
-### General issues
-
-1. If you find any error related to `cURL`, please set up cURL on your machine. For Linux, you can use `sudo apt install curl`. No need to set up `cURL` for Windows as you are using git bash command line.<br>
-
-
-2. If you find any error which says `java: command not found`, please check you have Java installed correctly in your machine and the [environment path variable](https://www.java.com/en/download/help/path.html) is also set up correctly.
-
-
-3. If you find any error related to Kotlin or Java/Checkstyle while pushing the code, please check [this link](https://github.com/oppia/oppia-android/wiki/Frequent-Errors-and-Solutions#push-failed).
-
-
-4. If you see the error
-
-   ```
-   Could not resolve protoc-3.8.0-osx-aarch_64.exe (`com.google.protobuf:protoc:3.8.0`)
-   ```
-
-   then please follow the 2nd step mentioned in [this wiki](https://github.com/oppia/oppia-android/wiki/Installing-Oppia-Android#install-oppia-android) for Mac with Apple silicon(M1/M2) chips.
-
-
-5. If you see the error
-
-   ```
-   Deprecated Gradle features were used in this build, making it incompatible with Gradle 7.0.
-   ```
-
-   then it's fine to ignore it. The message just appears to be a warning. We don't use Gradle 7.0, so this warning is fine to ignore.
-
-6. If you see the error
-
-   ```
-   Error `Class 'org.oppia.android.app.profile.PinPasswordActivityTest' not found in module 'oppia-android.app'`
-   ```
-
-   or `Module not specified` while running Unit Tests, try to downgrade Android Studio to [Bumblebee (Patch 3)](https://developer.android.com/studio/archive). That should resolve this issue.
-
-
-7. If you encounter this error while building gradle:
-
-   ```
-   > Task :utility:kaptGenerateStubsDebugKotlin FAILED
-   Execution failed for task ':utility:kaptGenerateStubsDebugKotlin'.
-   > Could not resolve all files for configuration ':utility:debugCompileClasspath'.
-      > Failed to transform model.jar (project :model) to match attributes {artifactType=android-classes, org.gradle.category=library, org.gradle.dependency.bundling=external, org.gradle.jvm.version=15, org.gradle.libraryelements=jar, org.gradle.usage=java-api}.
-         > Execution failed for JetifyTransform: E:\Android\open-source\oppia-android\model\build\libs\model.jar.
-            > Failed to transform 'E:\Android\open-source\oppia-android\model\build\libs\model.jar' using Jetifier. Reason: Unsupported class file major version 59. (Run with --stacktrace for more details.)
-   ```
-   You are seeing this because Oppia android currently compiles with Java 8, or 9. Higher versions of Java are not supported by our version of Gradle.
-
-   The `model.jar` was compiled with Java 15/major version 59, hence the incompatibility.
-
-
-   To fix this error, you need to lower the version of Java to compile the JAR file. Please see [here](https://developer.android.com/studio/intro/studio-config#jdk) for more information about Java versions.
-
-### Bazel issues
path: wiki/Troubleshooting-Installation.md
user: login: adhiamboperes
body: I moved these over, except for the 
```
external/bazel_tools/src/tools/android/java/com/google/devtools/build/android/dexer/DexFileSplitter.java:21: error: package com.android.dex does not exist
   import com.android.dex.DexFormat;
```

which may have been useful during Bazel 4-6 migration, but is not likely to be an issue now.
created_at: 2025-03-14T09:22:16Z
author_association: CONTRIBUTOR
diff_hunk: @@ -64,7 +64,7 @@ The new comment should include an explicit indication of whether the audit was c
 ### Step 3: Testing the app & filing problems
 
 Compatibility with the new target SDK should be done by:
-1. Building a local production [Bazel build](https://github.com/oppia/oppia-android/wiki/Oppia-Bazel-Setup-Instructions#building-the-app) of the app (``//:oppia_beta``) and deployed to a local emulator or device running the **same** version of Android as the new target SDK version.
+1. Building a local production [Bazel build](https://github.com/oppia/oppia-android/wiki/Oppia-Bazel-Glossary#building-the-app) of the app (``//:oppia_beta``) and deployed to a local emulator or device running the **same** version of Android as the new target SDK version.
path: wiki/Upgrading-Target-Sdk-Guide.md
user: login: adhiamboperes
body: Done
created_at: 2025-03-14T09:23:27Z
author_association: CONTRIBUTOR
diff_hunk: @@ -5,32 +5,313 @@ This wiki page explains how to install Oppia Android on your local machine. If y
 ## Table of Contents
 
 - [Prepare developer environment](#prepare-developer-environment)
+- [install Bazel](#install-bazel)
+  - [Bazel setup for Mac](#bazel-set-up-for-mac)
+  - [Bazel setup for Linux](#bazel-set-up-for-linux)
+  - [Bazel setup for Windows](#bazel-set-up-for-windows)
 - [Install oppia-android](#install-oppia-android)
 - [Run the app from Android Studio](#run-the-app-from-android-studio)
+- [Run the app from the command line](#run-the-app-from-the-command-line)
 - [Set up and Run tests](#set-up-and-run-tests)
   - [Step-by-Step guidance for setting up and running app modules robolectric test](#step-by-step-guidance-for-setting-up-and-running-app-modules-robolectric-test)
   - [For tests that are in non-app modules, such as **domain** or **utility**:](#for-tests-that-are-in-non-app-modules-such-as-domain-or-utility)
-
+- [Next Steps](#next-steps)
+- [Troubleshooting Installation](#troubleshooting-installation)
 
 ## Prepare developer environment
 
-1. Download/Install [Android Studio Bumblebee | Patch 3](https://developer.android.com/studio/archive).
-
-   **Note**: We recommend installing **Android Studio Bumblebee | 2021.1.1 Patch 3** because newer versions of Android Studio[ do not support running tests where shared source sets are used](https://issuetracker.google.com/issues/232007221#comment18), a configuration we use at Oppia.
-
-   **Direct download Url**: [Windows](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-windows.exe) | [Linux](https://redirector.gvt1.com/edgedl/android/studio/ide-zips/2021.1.1.23/android-studio-2021.1.1.23-linux.tar.gz) | [Intel Mac](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-mac.dmg) | [Apple Silicon Mac](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-mac_arm.dmg)
-
-   You can have multiple versions of Android Studio installed on your machine at the same time.
+1. Download/Install the latest version of Android Studio from [this location](https://developer.android.com/studio).
+   **Note**: We strongly recommend **Giraffe** because it has been tested and produced the best experience across different OSes.
path: wiki/Installing-Oppia-Android.md
user: login: adhiamboperes
body: Updated.
created_at: 2025-03-14T09:28:55Z
author_association: CONTRIBUTOR
diff_hunk: @@ -5,32 +5,313 @@ This wiki page explains how to install Oppia Android on your local machine. If y
 ## Table of Contents
 
 - [Prepare developer environment](#prepare-developer-environment)
+- [install Bazel](#install-bazel)
+  - [Bazel setup for Mac](#bazel-set-up-for-mac)
+  - [Bazel setup for Linux](#bazel-set-up-for-linux)
+  - [Bazel setup for Windows](#bazel-set-up-for-windows)
 - [Install oppia-android](#install-oppia-android)
 - [Run the app from Android Studio](#run-the-app-from-android-studio)
+- [Run the app from the command line](#run-the-app-from-the-command-line)
 - [Set up and Run tests](#set-up-and-run-tests)
   - [Step-by-Step guidance for setting up and running app modules robolectric test](#step-by-step-guidance-for-setting-up-and-running-app-modules-robolectric-test)
   - [For tests that are in non-app modules, such as **domain** or **utility**:](#for-tests-that-are-in-non-app-modules-such-as-domain-or-utility)
-
+- [Next Steps](#next-steps)
+- [Troubleshooting Installation](#troubleshooting-installation)
 
 ## Prepare developer environment
 
-1. Download/Install [Android Studio Bumblebee | Patch 3](https://developer.android.com/studio/archive).
-
-   **Note**: We recommend installing **Android Studio Bumblebee | 2021.1.1 Patch 3** because newer versions of Android Studio[ do not support running tests where shared source sets are used](https://issuetracker.google.com/issues/232007221#comment18), a configuration we use at Oppia.
-
-   **Direct download Url**: [Windows](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-windows.exe) | [Linux](https://redirector.gvt1.com/edgedl/android/studio/ide-zips/2021.1.1.23/android-studio-2021.1.1.23-linux.tar.gz) | [Intel Mac](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-mac.dmg) | [Apple Silicon Mac](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-mac_arm.dmg)
-
-   You can have multiple versions of Android Studio installed on your machine at the same time.
+1. Download/Install the latest version of Android Studio from [this location](https://developer.android.com/studio).
+   **Note**: We strongly recommend **Giraffe** because it has been tested and produced the best experience across different OSes.
 
 2. Configure your Android Studio
-   - In Android Studio, open Tools > SDK Manager.
-     - In the "SDK Platforms" tab (which is the default), select `API Level 28` and also `API Level 30` (for Bazel support).
+   - In Android Studio, open **Tools** > **SDK Manager**.
path: wiki/Installing-Oppia-Android.md
user: login: adhiamboperes
body: Updated to setup the tools from the welcome screen.
created_at: 2025-03-14T09:40:28Z
author_association: CONTRIBUTOR
diff_hunk: @@ -5,32 +5,313 @@ This wiki page explains how to install Oppia Android on your local machine. If y
 ## Table of Contents
 
 - [Prepare developer environment](#prepare-developer-environment)
+- [install Bazel](#install-bazel)
+  - [Bazel setup for Mac](#bazel-set-up-for-mac)
+  - [Bazel setup for Linux](#bazel-set-up-for-linux)
+  - [Bazel setup for Windows](#bazel-set-up-for-windows)
 - [Install oppia-android](#install-oppia-android)
 - [Run the app from Android Studio](#run-the-app-from-android-studio)
+- [Run the app from the command line](#run-the-app-from-the-command-line)
 - [Set up and Run tests](#set-up-and-run-tests)
   - [Step-by-Step guidance for setting up and running app modules robolectric test](#step-by-step-guidance-for-setting-up-and-running-app-modules-robolectric-test)
   - [For tests that are in non-app modules, such as **domain** or **utility**:](#for-tests-that-are-in-non-app-modules-such-as-domain-or-utility)
-
+- [Next Steps](#next-steps)
+- [Troubleshooting Installation](#troubleshooting-installation)
 
 ## Prepare developer environment
 
-1. Download/Install [Android Studio Bumblebee | Patch 3](https://developer.android.com/studio/archive).
-
-   **Note**: We recommend installing **Android Studio Bumblebee | 2021.1.1 Patch 3** because newer versions of Android Studio[ do not support running tests where shared source sets are used](https://issuetracker.google.com/issues/232007221#comment18), a configuration we use at Oppia.
-
-   **Direct download Url**: [Windows](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-windows.exe) | [Linux](https://redirector.gvt1.com/edgedl/android/studio/ide-zips/2021.1.1.23/android-studio-2021.1.1.23-linux.tar.gz) | [Intel Mac](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-mac.dmg) | [Apple Silicon Mac](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-mac_arm.dmg)
-
-   You can have multiple versions of Android Studio installed on your machine at the same time.
+1. Download/Install the latest version of Android Studio from [this location](https://developer.android.com/studio).
+   **Note**: We strongly recommend **Giraffe** because it has been tested and produced the best experience across different OSes.
 
 2. Configure your Android Studio
-   - In Android Studio, open Tools > SDK Manager.
-     - In the "SDK Platforms" tab (which is the default), select `API Level 28` and also `API Level 30` (for Bazel support).
+   - In Android Studio, open **Tools** > **SDK Manager**.
+     - In the "SDK Platforms" tab (which is the default), select `API Level 29` and also `API Level 30`.
path: wiki/Installing-Oppia-Android.md
user: login: adhiamboperes
body: Done
created_at: 2025-03-14T09:40:39Z
author_association: CONTRIBUTOR
diff_hunk: @@ -5,32 +5,313 @@ This wiki page explains how to install Oppia Android on your local machine. If y
 ## Table of Contents
 
 - [Prepare developer environment](#prepare-developer-environment)
+- [install Bazel](#install-bazel)
+  - [Bazel setup for Mac](#bazel-set-up-for-mac)
+  - [Bazel setup for Linux](#bazel-set-up-for-linux)
+  - [Bazel setup for Windows](#bazel-set-up-for-windows)
 - [Install oppia-android](#install-oppia-android)
 - [Run the app from Android Studio](#run-the-app-from-android-studio)
+- [Run the app from the command line](#run-the-app-from-the-command-line)
 - [Set up and Run tests](#set-up-and-run-tests)
   - [Step-by-Step guidance for setting up and running app modules robolectric test](#step-by-step-guidance-for-setting-up-and-running-app-modules-robolectric-test)
   - [For tests that are in non-app modules, such as **domain** or **utility**:](#for-tests-that-are-in-non-app-modules-such-as-domain-or-utility)
-
+- [Next Steps](#next-steps)
+- [Troubleshooting Installation](#troubleshooting-installation)
 
 ## Prepare developer environment
 
-1. Download/Install [Android Studio Bumblebee | Patch 3](https://developer.android.com/studio/archive).
-
-   **Note**: We recommend installing **Android Studio Bumblebee | 2021.1.1 Patch 3** because newer versions of Android Studio[ do not support running tests where shared source sets are used](https://issuetracker.google.com/issues/232007221#comment18), a configuration we use at Oppia.
-
-   **Direct download Url**: [Windows](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-windows.exe) | [Linux](https://redirector.gvt1.com/edgedl/android/studio/ide-zips/2021.1.1.23/android-studio-2021.1.1.23-linux.tar.gz) | [Intel Mac](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-mac.dmg) | [Apple Silicon Mac](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-mac_arm.dmg)
-
-   You can have multiple versions of Android Studio installed on your machine at the same time.
+1. Download/Install the latest version of Android Studio from [this location](https://developer.android.com/studio).
+   **Note**: We strongly recommend **Giraffe** because it has been tested and produced the best experience across different OSes.
 
 2. Configure your Android Studio
-   - In Android Studio, open Tools > SDK Manager.
-     - In the "SDK Platforms" tab (which is the default), select `API Level 28` and also `API Level 30` (for Bazel support).
+   - In Android Studio, open **Tools** > **SDK Manager**.
+     - In the "SDK Platforms" tab (which is the default), select `API Level 29` and also `API Level 30`.
      - Also, navigate to the "SDK Tools" tab, click the "Show Package Details" checkbox at the bottom right, then click on "Android SDK Build-Tools 34-rc1" and select 32.0.0 (this is needed for Bazel support).
 
    - Then, click "Apply" to download and install these two SDKs/Tools.
 
-   - Must have **JDK 11** selected:
-     - In Android Studio, open Settings > Build, Execution, Deployment > Build Tools > Gradle and edit the Gradle JDK field.
+3. Prepare a test device
+   You require a physical Android device or an Android emulator to run the Oppia app. 
+   - Physical devices are useful for a real-user experience feel, and testing with [accessibility tools](https://github.com/oppia/oppia-android/wiki/Accessibility-A11y-Guide#setting-up-accessibility-scanner-and-talkback).
+   
+     **Set up a physical device for development**
+      - On the device, open the **Settings** app, select **Developer options**, and then **enable USB debugging** (if applicable).
+        - If you don't see **Developer options**, you might need to enable developer mode first. Follow [these instructions](https://developer.android.com/studio/debug/dev-options#enable) to do so.
+        - Connect to your device using USB.
+        - Verify that your device is connected by running the `adb devices` command from your terminal.
+   
+      - Emulators provide the flexibility of testing the application on a variety of devices and Android API levels without needing to have each physical device.
+   
+     **Set up an Emulator**
+      - For the best experience, you should use the emulator in Android Studio on a computer with at least the following specs:
+        - 16 GB RAM
+        - 64-bit Windows 10 or higher, MacOS 12 or higher, Linux, or ChromeOS operating system
+        - 16 GB disk space
+     
+      - If you don't have these specs, the emulator might still run but not smoothly. In this case, consider testing on a physical device.
+
+       - In Android Studio, in the right hand toolbar, locate `device Manager`.
+       - Click the **+**, and then click **Create Virtual Device**.
+       - Create a phone and a tablet AVD.
path: wiki/Installing-Oppia-Android.md
user: login: adhiamboperes
body: Added this information.
created_at: 2025-03-14T09:46:35Z
author_association: CONTRIBUTOR
diff_hunk: @@ -5,32 +5,313 @@ This wiki page explains how to install Oppia Android on your local machine. If y
 ## Table of Contents
 
 - [Prepare developer environment](#prepare-developer-environment)
+- [install Bazel](#install-bazel)
+  - [Bazel setup for Mac](#bazel-set-up-for-mac)
+  - [Bazel setup for Linux](#bazel-set-up-for-linux)
+  - [Bazel setup for Windows](#bazel-set-up-for-windows)
 - [Install oppia-android](#install-oppia-android)
 - [Run the app from Android Studio](#run-the-app-from-android-studio)
+- [Run the app from the command line](#run-the-app-from-the-command-line)
 - [Set up and Run tests](#set-up-and-run-tests)
   - [Step-by-Step guidance for setting up and running app modules robolectric test](#step-by-step-guidance-for-setting-up-and-running-app-modules-robolectric-test)
   - [For tests that are in non-app modules, such as **domain** or **utility**:](#for-tests-that-are-in-non-app-modules-such-as-domain-or-utility)
-
+- [Next Steps](#next-steps)
+- [Troubleshooting Installation](#troubleshooting-installation)
 
 ## Prepare developer environment
 
-1. Download/Install [Android Studio Bumblebee | Patch 3](https://developer.android.com/studio/archive).
-
-   **Note**: We recommend installing **Android Studio Bumblebee | 2021.1.1 Patch 3** because newer versions of Android Studio[ do not support running tests where shared source sets are used](https://issuetracker.google.com/issues/232007221#comment18), a configuration we use at Oppia.
-
-   **Direct download Url**: [Windows](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-windows.exe) | [Linux](https://redirector.gvt1.com/edgedl/android/studio/ide-zips/2021.1.1.23/android-studio-2021.1.1.23-linux.tar.gz) | [Intel Mac](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-mac.dmg) | [Apple Silicon Mac](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-mac_arm.dmg)
-
-   You can have multiple versions of Android Studio installed on your machine at the same time.
+1. Download/Install the latest version of Android Studio from [this location](https://developer.android.com/studio).
+   **Note**: We strongly recommend **Giraffe** because it has been tested and produced the best experience across different OSes.
 
 2. Configure your Android Studio
-   - In Android Studio, open Tools > SDK Manager.
-     - In the "SDK Platforms" tab (which is the default), select `API Level 28` and also `API Level 30` (for Bazel support).
+   - In Android Studio, open **Tools** > **SDK Manager**.
+     - In the "SDK Platforms" tab (which is the default), select `API Level 29` and also `API Level 30`.
      - Also, navigate to the "SDK Tools" tab, click the "Show Package Details" checkbox at the bottom right, then click on "Android SDK Build-Tools 34-rc1" and select 32.0.0 (this is needed for Bazel support).
 
    - Then, click "Apply" to download and install these two SDKs/Tools.
 
-   - Must have **JDK 11** selected:
-     - In Android Studio, open Settings > Build, Execution, Deployment > Build Tools > Gradle and edit the Gradle JDK field.
+3. Prepare a test device
+   You require a physical Android device or an Android emulator to run the Oppia app. 
+   - Physical devices are useful for a real-user experience feel, and testing with [accessibility tools](https://github.com/oppia/oppia-android/wiki/Accessibility-A11y-Guide#setting-up-accessibility-scanner-and-talkback).
+   
+     **Set up a physical device for development**
+      - On the device, open the **Settings** app, select **Developer options**, and then **enable USB debugging** (if applicable).
+        - If you don't see **Developer options**, you might need to enable developer mode first. Follow [these instructions](https://developer.android.com/studio/debug/dev-options#enable) to do so.
+        - Connect to your device using USB.
+        - Verify that your device is connected by running the `adb devices` command from your terminal.
+   
+      - Emulators provide the flexibility of testing the application on a variety of devices and Android API levels without needing to have each physical device.
+   
+     **Set up an Emulator**
+      - For the best experience, you should use the emulator in Android Studio on a computer with at least the following specs:
+        - 16 GB RAM
+        - 64-bit Windows 10 or higher, MacOS 12 or higher, Linux, or ChromeOS operating system
+        - 16 GB disk space
+     
+      - If you don't have these specs, the emulator might still run but not smoothly. In this case, consider testing on a physical device.
+
+       - In Android Studio, in the right hand toolbar, locate `device Manager`.
+       - Click the **+**, and then click **Create Virtual Device**.
+       - Create a phone and a tablet AVD.
+       - After creating your devices, you will be able to see a list of all the devices on the device manager panel.
+       - For more information on the different configurations available for AVDs, please visit the [official documentation page.](https://developer.android.com/studio/run/managing-avds)
+
+## Install Bazel
+### Instructions
+
+**The steps to setting up Bazel are:**
+1. Install Bazel
+2. Set Bazel and ANDROID_HOME paths permanently in your terminal
+3. Verify that the build is working
+
+The expected output of `bazel --version` once Bazel set up is successful is:
+
+```
+bazel 6.5.0
+```
+
+### Bazel Set up for Mac
+It is recommended to use the binary installer steps outline below. For other ways to install Bazel on Mac, refer to the [official page](https://bazel.build/install/os-x).
+
+**Step 1: Install Xcode command line tools**
+
+In macOS 14 or earlier, it is sufficient to install the Xcode command line tools package by using xcode-select:
+
+```
+xcode-select --install
+```
+
+Otherwise, for macOS 15 and later, you must have Xcode 6.1 or later installed on your system.
+
+Download Xcode from the [App Store](https://apps.apple.com/us/app/xcode/id497799835) or the [Apple Developer site](https://developer.apple.com/download/more/?=xcode).
+
+Once Xcode is installed, accept the license agreement for all users with the following command:
+
+```
+sudo xcodebuild -license accept
+```
+
+**Step 2: Download the Bazel installer**
+
+Click [here](https://github.com/bazelbuild/bazel/releases/download/6.5.0/bazel-6.5.0-installer-darwin-x86_64.sh) to download the Bazel 6.5.0 binary installer.
+
+**Step 3: Run the installer**
+
+Run the Bazel installer as follows:
+
+```shell
+chmod +x "bazel-6.5.0-installer-darwin-x86_64.sh"
+./bazel-6.5.0-installer-darwin-x86_64.sh --user
+```
+
+**Step 4: Set up your environment**
+
+You must set the path for `Bazel` and `ANDROID_HOME` before running bazel build for oppia-android, otherwise you will get an error.
+
+If you ran the Bazel installer with the `--user` flag as above, the Bazel executable is installed in your $HOME/bin directory. It’s a good idea to add this directory to your default paths, as follows:
+
+```shell
+export PATH="$PATH:$HOME/bin"
+```
+
+To set the `ANDROID_HOME` path permanently in your terminal run these commands:
+
+```
+sudo nano /etc/paths
+```
+- Enter your password, when prompted.
+- Go to the bottom of the file, and enter this path: `$HOME/Library/Android/sdk`
+- Hit control-x to quit.
+- Enter “Y” to save the modified buffer.
+- That’s it! To test it, in a new terminal window, type: `echo $PATH`
+
+**Step 5: Verify that the build is working**
+
+Run the following command in your terminal:
+
+```
+bazel --version
+```
+
+### Bazel Set up for Linux
+This section covers Bazel installation on Ubuntu. 
+
+Recommendations:
+- use Ubuntu 18.04 (LTS), 20.04 (LTS), or 22.04 (LTS).
+- use ``apt`` installation instructions.
+
+- **Note**: if you encounter any errors related to `cURL`, please set up cURL on your machine using `sudo apt install curl`.
+
+**Step 1: Add Bazel distribution URI as a package source**
+
+This is a one-time setup step.
+
+```
+sudo apt install apt-transport-https curl gnupg -y
+curl -fsSL https://bazel.build/bazel-release.pub.gpg | gpg --dearmor >bazel-archive-keyring.gpg
+sudo mv bazel-archive-keyring.gpg /usr/share/keyrings
+echo "deb [arch=amd64 signed-by=/usr/share/keyrings/bazel-archive-keyring.gpg] https://storage.googleapis.com/bazel-apt stable jdk1.8" | sudo tee /etc/apt/sources.list.d/bazel.list
+```
+
+**Step 2: Install and update Bazel**
+
+Run:
+```shell
+sudo apt update && sudo apt install bazel-6.5.0
path: wiki/Installing-Oppia-Android.md
user: login: adhiamboperes
body: Ohh...Updated.
created_at: 2025-03-14T09:54:09Z
author_association: CONTRIBUTOR
diff_hunk: @@ -5,32 +5,313 @@ This wiki page explains how to install Oppia Android on your local machine. If y
 ## Table of Contents
 
 - [Prepare developer environment](#prepare-developer-environment)
+- [install Bazel](#install-bazel)
+  - [Bazel setup for Mac](#bazel-set-up-for-mac)
+  - [Bazel setup for Linux](#bazel-set-up-for-linux)
+  - [Bazel setup for Windows](#bazel-set-up-for-windows)
 - [Install oppia-android](#install-oppia-android)
 - [Run the app from Android Studio](#run-the-app-from-android-studio)
+- [Run the app from the command line](#run-the-app-from-the-command-line)
 - [Set up and Run tests](#set-up-and-run-tests)
   - [Step-by-Step guidance for setting up and running app modules robolectric test](#step-by-step-guidance-for-setting-up-and-running-app-modules-robolectric-test)
   - [For tests that are in non-app modules, such as **domain** or **utility**:](#for-tests-that-are-in-non-app-modules-such-as-domain-or-utility)
-
+- [Next Steps](#next-steps)
+- [Troubleshooting Installation](#troubleshooting-installation)
 
 ## Prepare developer environment
 
-1. Download/Install [Android Studio Bumblebee | Patch 3](https://developer.android.com/studio/archive).
-
-   **Note**: We recommend installing **Android Studio Bumblebee | 2021.1.1 Patch 3** because newer versions of Android Studio[ do not support running tests where shared source sets are used](https://issuetracker.google.com/issues/232007221#comment18), a configuration we use at Oppia.
-
-   **Direct download Url**: [Windows](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-windows.exe) | [Linux](https://redirector.gvt1.com/edgedl/android/studio/ide-zips/2021.1.1.23/android-studio-2021.1.1.23-linux.tar.gz) | [Intel Mac](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-mac.dmg) | [Apple Silicon Mac](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-mac_arm.dmg)
-
-   You can have multiple versions of Android Studio installed on your machine at the same time.
+1. Download/Install the latest version of Android Studio from [this location](https://developer.android.com/studio).
+   **Note**: We strongly recommend **Giraffe** because it has been tested and produced the best experience across different OSes.
 
 2. Configure your Android Studio
-   - In Android Studio, open Tools > SDK Manager.
-     - In the "SDK Platforms" tab (which is the default), select `API Level 28` and also `API Level 30` (for Bazel support).
+   - In Android Studio, open **Tools** > **SDK Manager**.
+     - In the "SDK Platforms" tab (which is the default), select `API Level 29` and also `API Level 30`.
      - Also, navigate to the "SDK Tools" tab, click the "Show Package Details" checkbox at the bottom right, then click on "Android SDK Build-Tools 34-rc1" and select 32.0.0 (this is needed for Bazel support).
 
    - Then, click "Apply" to download and install these two SDKs/Tools.
 
-   - Must have **JDK 11** selected:
-     - In Android Studio, open Settings > Build, Execution, Deployment > Build Tools > Gradle and edit the Gradle JDK field.
+3. Prepare a test device
+   You require a physical Android device or an Android emulator to run the Oppia app. 
+   - Physical devices are useful for a real-user experience feel, and testing with [accessibility tools](https://github.com/oppia/oppia-android/wiki/Accessibility-A11y-Guide#setting-up-accessibility-scanner-and-talkback).
+   
+     **Set up a physical device for development**
+      - On the device, open the **Settings** app, select **Developer options**, and then **enable USB debugging** (if applicable).
+        - If you don't see **Developer options**, you might need to enable developer mode first. Follow [these instructions](https://developer.android.com/studio/debug/dev-options#enable) to do so.
+        - Connect to your device using USB.
+        - Verify that your device is connected by running the `adb devices` command from your terminal.
+   
+      - Emulators provide the flexibility of testing the application on a variety of devices and Android API levels without needing to have each physical device.
+   
+     **Set up an Emulator**
+      - For the best experience, you should use the emulator in Android Studio on a computer with at least the following specs:
+        - 16 GB RAM
+        - 64-bit Windows 10 or higher, MacOS 12 or higher, Linux, or ChromeOS operating system
+        - 16 GB disk space
+     
+      - If you don't have these specs, the emulator might still run but not smoothly. In this case, consider testing on a physical device.
+
+       - In Android Studio, in the right hand toolbar, locate `device Manager`.
+       - Click the **+**, and then click **Create Virtual Device**.
+       - Create a phone and a tablet AVD.
+       - After creating your devices, you will be able to see a list of all the devices on the device manager panel.
+       - For more information on the different configurations available for AVDs, please visit the [official documentation page.](https://developer.android.com/studio/run/managing-avds)
+
+## Install Bazel
+### Instructions
+
+**The steps to setting up Bazel are:**
+1. Install Bazel
+2. Set Bazel and ANDROID_HOME paths permanently in your terminal
+3. Verify that the build is working
+
+The expected output of `bazel --version` once Bazel set up is successful is:
+
+```
+bazel 6.5.0
+```
+
+### Bazel Set up for Mac
+It is recommended to use the binary installer steps outline below. For other ways to install Bazel on Mac, refer to the [official page](https://bazel.build/install/os-x).
+
+**Step 1: Install Xcode command line tools**
+
+In macOS 14 or earlier, it is sufficient to install the Xcode command line tools package by using xcode-select:
+
+```
+xcode-select --install
+```
+
+Otherwise, for macOS 15 and later, you must have Xcode 6.1 or later installed on your system.
+
+Download Xcode from the [App Store](https://apps.apple.com/us/app/xcode/id497799835) or the [Apple Developer site](https://developer.apple.com/download/more/?=xcode).
+
+Once Xcode is installed, accept the license agreement for all users with the following command:
+
+```
+sudo xcodebuild -license accept
+```
+
+**Step 2: Download the Bazel installer**
+
+Click [here](https://github.com/bazelbuild/bazel/releases/download/6.5.0/bazel-6.5.0-installer-darwin-x86_64.sh) to download the Bazel 6.5.0 binary installer.
+
+**Step 3: Run the installer**
+
+Run the Bazel installer as follows:
+
+```shell
+chmod +x "bazel-6.5.0-installer-darwin-x86_64.sh"
+./bazel-6.5.0-installer-darwin-x86_64.sh --user
+```
+
+**Step 4: Set up your environment**
+
+You must set the path for `Bazel` and `ANDROID_HOME` before running bazel build for oppia-android, otherwise you will get an error.
+
+If you ran the Bazel installer with the `--user` flag as above, the Bazel executable is installed in your $HOME/bin directory. It’s a good idea to add this directory to your default paths, as follows:
+
+```shell
+export PATH="$PATH:$HOME/bin"
+```
+
+To set the `ANDROID_HOME` path permanently in your terminal run these commands:
+
+```
+sudo nano /etc/paths
+```
+- Enter your password, when prompted.
+- Go to the bottom of the file, and enter this path: `$HOME/Library/Android/sdk`
+- Hit control-x to quit.
+- Enter “Y” to save the modified buffer.
+- That’s it! To test it, in a new terminal window, type: `echo $PATH`
+
+**Step 5: Verify that the build is working**
+
+Run the following command in your terminal:
+
+```
+bazel --version
+```
+
+### Bazel Set up for Linux
+This section covers Bazel installation on Ubuntu. 
+
+Recommendations:
+- use Ubuntu 18.04 (LTS), 20.04 (LTS), or 22.04 (LTS).
+- use ``apt`` installation instructions.
+
+- **Note**: if you encounter any errors related to `cURL`, please set up cURL on your machine using `sudo apt install curl`.
+
+**Step 1: Add Bazel distribution URI as a package source**
+
+This is a one-time setup step.
+
+```
+sudo apt install apt-transport-https curl gnupg -y
+curl -fsSL https://bazel.build/bazel-release.pub.gpg | gpg --dearmor >bazel-archive-keyring.gpg
+sudo mv bazel-archive-keyring.gpg /usr/share/keyrings
+echo "deb [arch=amd64 signed-by=/usr/share/keyrings/bazel-archive-keyring.gpg] https://storage.googleapis.com/bazel-apt stable jdk1.8" | sudo tee /etc/apt/sources.list.d/bazel.list
+```
+
+**Step 2: Install and update Bazel**
+
+Run:
+```shell
+sudo apt update && sudo apt install bazel-6.5.0
+```
+
+**Step 3: Set up your environment**
+
+Ensure that your `ANDROID_HOME` environment variable is set to the location of your Android SDK. To do this, find the path to the installed SDK using Android Studio’s SDK Manager (install SDK 28). Assuming the SDK is installed to default locations, you can use the following commands to set the `ANDROID_HOME` variable:<br>
path: wiki/Installing-Oppia-Android.md
user: login: adhiamboperes
body: Done.
created_at: 2025-03-14T10:00:10Z
author_association: CONTRIBUTOR
diff_hunk: @@ -5,32 +5,313 @@ This wiki page explains how to install Oppia Android on your local machine. If y
 ## Table of Contents
 
 - [Prepare developer environment](#prepare-developer-environment)
+- [install Bazel](#install-bazel)
+  - [Bazel setup for Mac](#bazel-set-up-for-mac)
+  - [Bazel setup for Linux](#bazel-set-up-for-linux)
+  - [Bazel setup for Windows](#bazel-set-up-for-windows)
 - [Install oppia-android](#install-oppia-android)
 - [Run the app from Android Studio](#run-the-app-from-android-studio)
+- [Run the app from the command line](#run-the-app-from-the-command-line)
 - [Set up and Run tests](#set-up-and-run-tests)
   - [Step-by-Step guidance for setting up and running app modules robolectric test](#step-by-step-guidance-for-setting-up-and-running-app-modules-robolectric-test)
   - [For tests that are in non-app modules, such as **domain** or **utility**:](#for-tests-that-are-in-non-app-modules-such-as-domain-or-utility)
-
+- [Next Steps](#next-steps)
+- [Troubleshooting Installation](#troubleshooting-installation)
 
 ## Prepare developer environment
 
-1. Download/Install [Android Studio Bumblebee | Patch 3](https://developer.android.com/studio/archive).
-
-   **Note**: We recommend installing **Android Studio Bumblebee | 2021.1.1 Patch 3** because newer versions of Android Studio[ do not support running tests where shared source sets are used](https://issuetracker.google.com/issues/232007221#comment18), a configuration we use at Oppia.
-
-   **Direct download Url**: [Windows](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-windows.exe) | [Linux](https://redirector.gvt1.com/edgedl/android/studio/ide-zips/2021.1.1.23/android-studio-2021.1.1.23-linux.tar.gz) | [Intel Mac](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-mac.dmg) | [Apple Silicon Mac](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-mac_arm.dmg)
-
-   You can have multiple versions of Android Studio installed on your machine at the same time.
+1. Download/Install the latest version of Android Studio from [this location](https://developer.android.com/studio).
+   **Note**: We strongly recommend **Giraffe** because it has been tested and produced the best experience across different OSes.
 
 2. Configure your Android Studio
-   - In Android Studio, open Tools > SDK Manager.
-     - In the "SDK Platforms" tab (which is the default), select `API Level 28` and also `API Level 30` (for Bazel support).
+   - In Android Studio, open **Tools** > **SDK Manager**.
+     - In the "SDK Platforms" tab (which is the default), select `API Level 29` and also `API Level 30`.
      - Also, navigate to the "SDK Tools" tab, click the "Show Package Details" checkbox at the bottom right, then click on "Android SDK Build-Tools 34-rc1" and select 32.0.0 (this is needed for Bazel support).
 
    - Then, click "Apply" to download and install these two SDKs/Tools.
 
-   - Must have **JDK 11** selected:
-     - In Android Studio, open Settings > Build, Execution, Deployment > Build Tools > Gradle and edit the Gradle JDK field.
+3. Prepare a test device
+   You require a physical Android device or an Android emulator to run the Oppia app. 
+   - Physical devices are useful for a real-user experience feel, and testing with [accessibility tools](https://github.com/oppia/oppia-android/wiki/Accessibility-A11y-Guide#setting-up-accessibility-scanner-and-talkback).
+   
+     **Set up a physical device for development**
+      - On the device, open the **Settings** app, select **Developer options**, and then **enable USB debugging** (if applicable).
+        - If you don't see **Developer options**, you might need to enable developer mode first. Follow [these instructions](https://developer.android.com/studio/debug/dev-options#enable) to do so.
+        - Connect to your device using USB.
+        - Verify that your device is connected by running the `adb devices` command from your terminal.
+   
+      - Emulators provide the flexibility of testing the application on a variety of devices and Android API levels without needing to have each physical device.
+   
+     **Set up an Emulator**
+      - For the best experience, you should use the emulator in Android Studio on a computer with at least the following specs:
+        - 16 GB RAM
+        - 64-bit Windows 10 or higher, MacOS 12 or higher, Linux, or ChromeOS operating system
+        - 16 GB disk space
+     
+      - If you don't have these specs, the emulator might still run but not smoothly. In this case, consider testing on a physical device.
+
+       - In Android Studio, in the right hand toolbar, locate `device Manager`.
+       - Click the **+**, and then click **Create Virtual Device**.
+       - Create a phone and a tablet AVD.
+       - After creating your devices, you will be able to see a list of all the devices on the device manager panel.
+       - For more information on the different configurations available for AVDs, please visit the [official documentation page.](https://developer.android.com/studio/run/managing-avds)
+
+## Install Bazel
+### Instructions
+
+**The steps to setting up Bazel are:**
+1. Install Bazel
+2. Set Bazel and ANDROID_HOME paths permanently in your terminal
+3. Verify that the build is working
+
+The expected output of `bazel --version` once Bazel set up is successful is:
+
+```
+bazel 6.5.0
+```
+
+### Bazel Set up for Mac
+It is recommended to use the binary installer steps outline below. For other ways to install Bazel on Mac, refer to the [official page](https://bazel.build/install/os-x).
+
+**Step 1: Install Xcode command line tools**
+
+In macOS 14 or earlier, it is sufficient to install the Xcode command line tools package by using xcode-select:
+
+```
+xcode-select --install
+```
+
+Otherwise, for macOS 15 and later, you must have Xcode 6.1 or later installed on your system.
+
+Download Xcode from the [App Store](https://apps.apple.com/us/app/xcode/id497799835) or the [Apple Developer site](https://developer.apple.com/download/more/?=xcode).
+
+Once Xcode is installed, accept the license agreement for all users with the following command:
+
+```
+sudo xcodebuild -license accept
+```
+
+**Step 2: Download the Bazel installer**
+
+Click [here](https://github.com/bazelbuild/bazel/releases/download/6.5.0/bazel-6.5.0-installer-darwin-x86_64.sh) to download the Bazel 6.5.0 binary installer.
+
+**Step 3: Run the installer**
+
+Run the Bazel installer as follows:
+
+```shell
+chmod +x "bazel-6.5.0-installer-darwin-x86_64.sh"
+./bazel-6.5.0-installer-darwin-x86_64.sh --user
+```
+
+**Step 4: Set up your environment**
+
+You must set the path for `Bazel` and `ANDROID_HOME` before running bazel build for oppia-android, otherwise you will get an error.
+
+If you ran the Bazel installer with the `--user` flag as above, the Bazel executable is installed in your $HOME/bin directory. It’s a good idea to add this directory to your default paths, as follows:
+
+```shell
+export PATH="$PATH:$HOME/bin"
+```
+
+To set the `ANDROID_HOME` path permanently in your terminal run these commands:
+
+```
+sudo nano /etc/paths
+```
+- Enter your password, when prompted.
+- Go to the bottom of the file, and enter this path: `$HOME/Library/Android/sdk`
+- Hit control-x to quit.
+- Enter “Y” to save the modified buffer.
+- That’s it! To test it, in a new terminal window, type: `echo $PATH`
+
+**Step 5: Verify that the build is working**
+
+Run the following command in your terminal:
+
+```
+bazel --version
+```
+
+### Bazel Set up for Linux
+This section covers Bazel installation on Ubuntu. 
+
+Recommendations:
+- use Ubuntu 18.04 (LTS), 20.04 (LTS), or 22.04 (LTS).
+- use ``apt`` installation instructions.
+
+- **Note**: if you encounter any errors related to `cURL`, please set up cURL on your machine using `sudo apt install curl`.
+
+**Step 1: Add Bazel distribution URI as a package source**
+
+This is a one-time setup step.
+
+```
+sudo apt install apt-transport-https curl gnupg -y
+curl -fsSL https://bazel.build/bazel-release.pub.gpg | gpg --dearmor >bazel-archive-keyring.gpg
+sudo mv bazel-archive-keyring.gpg /usr/share/keyrings
+echo "deb [arch=amd64 signed-by=/usr/share/keyrings/bazel-archive-keyring.gpg] https://storage.googleapis.com/bazel-apt stable jdk1.8" | sudo tee /etc/apt/sources.list.d/bazel.list
+```
+
+**Step 2: Install and update Bazel**
+
+Run:
+```shell
+sudo apt update && sudo apt install bazel-6.5.0
+```
+
+**Step 3: Set up your environment**
+
+Ensure that your `ANDROID_HOME` environment variable is set to the location of your Android SDK. To do this, find the path to the installed SDK using Android Studio’s SDK Manager (install SDK 28). Assuming the SDK is installed to default locations, you can use the following commands to set the `ANDROID_HOME` variable:<br>
+```
+export ANDROID_HOME=$HOME/Android/Sdk/
+```
+
+**Step 4: Verify that the build is working**
+
+Run the following command in your terminal:
+
+```
+bazel --version
+```
+
+### Bazel Set up for Windows
+This page outlines one way to allow Bazel to be used in CLI form on Windows. Please note that **this support is currently experimental**. You may run into some problems--we suggest that you post a discussion at [github-discussions](https://github.com/oppia/oppia-android/discussions).
path: wiki/Installing-Oppia-Android.md
user: login: adhiamboperes
body: Done.
created_at: 2025-03-14T10:02:49Z
author_association: CONTRIBUTOR
diff_hunk: @@ -5,32 +5,313 @@ This wiki page explains how to install Oppia Android on your local machine. If y
 ## Table of Contents
 
 - [Prepare developer environment](#prepare-developer-environment)
+- [install Bazel](#install-bazel)
+  - [Bazel setup for Mac](#bazel-set-up-for-mac)
+  - [Bazel setup for Linux](#bazel-set-up-for-linux)
+  - [Bazel setup for Windows](#bazel-set-up-for-windows)
 - [Install oppia-android](#install-oppia-android)
 - [Run the app from Android Studio](#run-the-app-from-android-studio)
+- [Run the app from the command line](#run-the-app-from-the-command-line)
 - [Set up and Run tests](#set-up-and-run-tests)
   - [Step-by-Step guidance for setting up and running app modules robolectric test](#step-by-step-guidance-for-setting-up-and-running-app-modules-robolectric-test)
   - [For tests that are in non-app modules, such as **domain** or **utility**:](#for-tests-that-are-in-non-app-modules-such-as-domain-or-utility)
-
+- [Next Steps](#next-steps)
+- [Troubleshooting Installation](#troubleshooting-installation)
 
 ## Prepare developer environment
 
-1. Download/Install [Android Studio Bumblebee | Patch 3](https://developer.android.com/studio/archive).
-
-   **Note**: We recommend installing **Android Studio Bumblebee | 2021.1.1 Patch 3** because newer versions of Android Studio[ do not support running tests where shared source sets are used](https://issuetracker.google.com/issues/232007221#comment18), a configuration we use at Oppia.
-
-   **Direct download Url**: [Windows](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-windows.exe) | [Linux](https://redirector.gvt1.com/edgedl/android/studio/ide-zips/2021.1.1.23/android-studio-2021.1.1.23-linux.tar.gz) | [Intel Mac](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-mac.dmg) | [Apple Silicon Mac](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-mac_arm.dmg)
-
-   You can have multiple versions of Android Studio installed on your machine at the same time.
+1. Download/Install the latest version of Android Studio from [this location](https://developer.android.com/studio).
+   **Note**: We strongly recommend **Giraffe** because it has been tested and produced the best experience across different OSes.
 
 2. Configure your Android Studio
-   - In Android Studio, open Tools > SDK Manager.
-     - In the "SDK Platforms" tab (which is the default), select `API Level 28` and also `API Level 30` (for Bazel support).
+   - In Android Studio, open **Tools** > **SDK Manager**.
+     - In the "SDK Platforms" tab (which is the default), select `API Level 29` and also `API Level 30`.
      - Also, navigate to the "SDK Tools" tab, click the "Show Package Details" checkbox at the bottom right, then click on "Android SDK Build-Tools 34-rc1" and select 32.0.0 (this is needed for Bazel support).
 
    - Then, click "Apply" to download and install these two SDKs/Tools.
 
-   - Must have **JDK 11** selected:
-     - In Android Studio, open Settings > Build, Execution, Deployment > Build Tools > Gradle and edit the Gradle JDK field.
+3. Prepare a test device
+   You require a physical Android device or an Android emulator to run the Oppia app. 
+   - Physical devices are useful for a real-user experience feel, and testing with [accessibility tools](https://github.com/oppia/oppia-android/wiki/Accessibility-A11y-Guide#setting-up-accessibility-scanner-and-talkback).
+   
+     **Set up a physical device for development**
+      - On the device, open the **Settings** app, select **Developer options**, and then **enable USB debugging** (if applicable).
+        - If you don't see **Developer options**, you might need to enable developer mode first. Follow [these instructions](https://developer.android.com/studio/debug/dev-options#enable) to do so.
+        - Connect to your device using USB.
+        - Verify that your device is connected by running the `adb devices` command from your terminal.
+   
+      - Emulators provide the flexibility of testing the application on a variety of devices and Android API levels without needing to have each physical device.
+   
+     **Set up an Emulator**
+      - For the best experience, you should use the emulator in Android Studio on a computer with at least the following specs:
+        - 16 GB RAM
+        - 64-bit Windows 10 or higher, MacOS 12 or higher, Linux, or ChromeOS operating system
+        - 16 GB disk space
+     
+      - If you don't have these specs, the emulator might still run but not smoothly. In this case, consider testing on a physical device.
+
+       - In Android Studio, in the right hand toolbar, locate `device Manager`.
+       - Click the **+**, and then click **Create Virtual Device**.
+       - Create a phone and a tablet AVD.
+       - After creating your devices, you will be able to see a list of all the devices on the device manager panel.
+       - For more information on the different configurations available for AVDs, please visit the [official documentation page.](https://developer.android.com/studio/run/managing-avds)
+
+## Install Bazel
+### Instructions
+
+**The steps to setting up Bazel are:**
+1. Install Bazel
+2. Set Bazel and ANDROID_HOME paths permanently in your terminal
+3. Verify that the build is working
+
+The expected output of `bazel --version` once Bazel set up is successful is:
+
+```
+bazel 6.5.0
+```
+
+### Bazel Set up for Mac
+It is recommended to use the binary installer steps outline below. For other ways to install Bazel on Mac, refer to the [official page](https://bazel.build/install/os-x).
+
+**Step 1: Install Xcode command line tools**
+
+In macOS 14 or earlier, it is sufficient to install the Xcode command line tools package by using xcode-select:
+
+```
+xcode-select --install
+```
+
+Otherwise, for macOS 15 and later, you must have Xcode 6.1 or later installed on your system.
+
+Download Xcode from the [App Store](https://apps.apple.com/us/app/xcode/id497799835) or the [Apple Developer site](https://developer.apple.com/download/more/?=xcode).
+
+Once Xcode is installed, accept the license agreement for all users with the following command:
+
+```
+sudo xcodebuild -license accept
+```
+
+**Step 2: Download the Bazel installer**
+
+Click [here](https://github.com/bazelbuild/bazel/releases/download/6.5.0/bazel-6.5.0-installer-darwin-x86_64.sh) to download the Bazel 6.5.0 binary installer.
+
+**Step 3: Run the installer**
+
+Run the Bazel installer as follows:
+
+```shell
+chmod +x "bazel-6.5.0-installer-darwin-x86_64.sh"
+./bazel-6.5.0-installer-darwin-x86_64.sh --user
+```
+
+**Step 4: Set up your environment**
+
+You must set the path for `Bazel` and `ANDROID_HOME` before running bazel build for oppia-android, otherwise you will get an error.
+
+If you ran the Bazel installer with the `--user` flag as above, the Bazel executable is installed in your $HOME/bin directory. It’s a good idea to add this directory to your default paths, as follows:
+
+```shell
+export PATH="$PATH:$HOME/bin"
+```
+
+To set the `ANDROID_HOME` path permanently in your terminal run these commands:
+
+```
+sudo nano /etc/paths
+```
+- Enter your password, when prompted.
+- Go to the bottom of the file, and enter this path: `$HOME/Library/Android/sdk`
+- Hit control-x to quit.
+- Enter “Y” to save the modified buffer.
+- That’s it! To test it, in a new terminal window, type: `echo $PATH`
+
+**Step 5: Verify that the build is working**
+
+Run the following command in your terminal:
+
+```
+bazel --version
+```
+
+### Bazel Set up for Linux
+This section covers Bazel installation on Ubuntu. 
+
+Recommendations:
+- use Ubuntu 18.04 (LTS), 20.04 (LTS), or 22.04 (LTS).
+- use ``apt`` installation instructions.
+
+- **Note**: if you encounter any errors related to `cURL`, please set up cURL on your machine using `sudo apt install curl`.
+
+**Step 1: Add Bazel distribution URI as a package source**
+
+This is a one-time setup step.
+
+```
+sudo apt install apt-transport-https curl gnupg -y
+curl -fsSL https://bazel.build/bazel-release.pub.gpg | gpg --dearmor >bazel-archive-keyring.gpg
+sudo mv bazel-archive-keyring.gpg /usr/share/keyrings
+echo "deb [arch=amd64 signed-by=/usr/share/keyrings/bazel-archive-keyring.gpg] https://storage.googleapis.com/bazel-apt stable jdk1.8" | sudo tee /etc/apt/sources.list.d/bazel.list
+```
+
+**Step 2: Install and update Bazel**
+
+Run:
+```shell
+sudo apt update && sudo apt install bazel-6.5.0
+```
+
+**Step 3: Set up your environment**
+
+Ensure that your `ANDROID_HOME` environment variable is set to the location of your Android SDK. To do this, find the path to the installed SDK using Android Studio’s SDK Manager (install SDK 28). Assuming the SDK is installed to default locations, you can use the following commands to set the `ANDROID_HOME` variable:<br>
+```
+export ANDROID_HOME=$HOME/Android/Sdk/
+```
+
+**Step 4: Verify that the build is working**
+
+Run the following command in your terminal:
+
+```
+bazel --version
+```
+
+### Bazel Set up for Windows
+This page outlines one way to allow Bazel to be used in CLI form on Windows. Please note that **this support is currently experimental**. You may run into some problems--we suggest that you post a discussion at [github-discussions](https://github.com/oppia/oppia-android/discussions).
+
+Unlike Unix-based systems where Bazel runs natively without issue, the current solution on Windows is to install an Ubuntu-based subsystem. Windows currently only supports a terminal experience in this subsystem (though there is a prerelease version of the software with GUI support) which means Android Studio will not be supported. You will need to continue using the Windows version of Android Studio and only use the Linux subsystem for building & running Robolectric or JUnit-based tests.
+
+Due to the issues mentioned above, we recommend dual-booting your PC with Linux. However, if you choose to use windows, please follow the instructions below:
path: wiki/Installing-Oppia-Android.md
user: login: adhiamboperes
body: Fixed
created_at: 2025-03-14T10:03:42Z
author_association: CONTRIBUTOR
diff_hunk: @@ -63,85 +341,183 @@ Please follow these steps to set up Oppia Android on your local machine.
        5. Download the [google_checks.xml](https://github.com/checkstyle/checkstyle/blob/14005e371803bd52dff429904b354dc3e72638c0/src/main/resources/google_checks.xml) file. To do this, you can simply right-click on the download button at the top-right of the file.
        6. Copy this file to the directory where Git is installed (usually C:/Program Files/Git/).
 
-3. In Android Studio, select `File > Open`, navigate to `opensource/oppia-android/`, and click `OK` to load the project.
-
-4. Select the Compile JDK version
-   - Go to Android Studio > Settings > Build, Execution, Deployment > Build Tools > Gradle
-   - Under "**Gradle JDK**", select Android Studio Default JDK 11.
-   - Then, click "Apply" and "OK" to complete your setup.
-5. Click the elephant icon in the toolbar ("Sync Gradle") to ensure that all the correct dependencies are downloaded. (In general, you'll want to do this step any time you update your dependencies.)
-
 ## Run the app from Android Studio
path: wiki/Installing-Oppia-Android.md
user: login: adhiamboperes
body: Updated to "Opening the project in Android Studio"
created_at: 2025-03-14T10:08:11Z
author_association: CONTRIBUTOR
diff_hunk: @@ -63,85 +341,183 @@ Please follow these steps to set up Oppia Android on your local machine.
        5. Download the [google_checks.xml](https://github.com/checkstyle/checkstyle/blob/14005e371803bd52dff429904b354dc3e72638c0/src/main/resources/google_checks.xml) file. To do this, you can simply right-click on the download button at the top-right of the file.
        6. Copy this file to the directory where Git is installed (usually C:/Program Files/Git/).
 
-3. In Android Studio, select `File > Open`, navigate to `opensource/oppia-android/`, and click `OK` to load the project.
-
-4. Select the Compile JDK version
-   - Go to Android Studio > Settings > Build, Execution, Deployment > Build Tools > Gradle
-   - Under "**Gradle JDK**", select Android Studio Default JDK 11.
-   - Then, click "Apply" and "OK" to complete your setup.
-5. Click the elephant icon in the toolbar ("Sync Gradle") to ensure that all the correct dependencies are downloaded. (In general, you'll want to do this step any time you update your dependencies.)
-
 ## Run the app from Android Studio
 
-1. Go to Tools > AVD Manager, click "Create Virtual Device...". Then:
+1. Launch Android Studio, and on the welcome screen, select **Plugins** to install the Bazel for Android Studio plugin and restart Android Studio.
 
-   - Select a preferred device definition. In general, any device is fine, but you can use Pixel 3a as a default (if you're developing for phones) or Nexus 7 (if you're developing for tablets). After selecting a device, click "Next" at the bottom right to continue.
-   - Select a system image (in general, API Level 28, unless you're an M1 Mac user, in which case use API Level 29). Then click "Next".
-   - Click "Finish" to complete setup.
+2. On next open, click the options button next to the new project/open project to find the "Import Bazel Project" option.
 
-2. To run the app, select the emulator device you want from the dropdown menu to the left of the "Run" button in the toolbar.
+   <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/efcc4e6e-b6ba-44fc-9c96-aa381de83911" />
 
-3. Finally, click the "Run" button.
+3. A setup wizard will open. For Workspace, click (**...**) to open file manager and select `/opensource/oppia-android` as the location since this is where we have our project's `WORKSPACE` file.
+
+   ![Image](https://github.com/user-attachments/assets/9baf6f71-560b-49fe-84a7-c7b846a64287)
+
+4. On **OK**, you will be asked to **Trust project**. Accept because we trust the project.
+
+   <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/bfc91f6d-d809-418d-ab20-89d899f12f72" />
+
+5. On **next**, to Select Project View, **select Create from scratch**.
+
+   <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/cdc110d6-2926-4f96-b7d8-117e2c716f76" />
+
+6. A file similar to the one below will be generated:
+
+   <img width="760" alt="Image" src="https://github.com/user-attachments/assets/5a26210f-865d-4048-b5a5-73379984bfb5" />
+
+7. In the above file, modify it so that it looks like below(copy and paste):
path: wiki/Installing-Oppia-Android.md
user: login: adhiamboperes
body: Fixed
created_at: 2025-03-14T10:09:01Z
author_association: CONTRIBUTOR
diff_hunk: @@ -63,85 +341,183 @@ Please follow these steps to set up Oppia Android on your local machine.
        5. Download the [google_checks.xml](https://github.com/checkstyle/checkstyle/blob/14005e371803bd52dff429904b354dc3e72638c0/src/main/resources/google_checks.xml) file. To do this, you can simply right-click on the download button at the top-right of the file.
        6. Copy this file to the directory where Git is installed (usually C:/Program Files/Git/).
 
-3. In Android Studio, select `File > Open`, navigate to `opensource/oppia-android/`, and click `OK` to load the project.
-
-4. Select the Compile JDK version
-   - Go to Android Studio > Settings > Build, Execution, Deployment > Build Tools > Gradle
-   - Under "**Gradle JDK**", select Android Studio Default JDK 11.
-   - Then, click "Apply" and "OK" to complete your setup.
-5. Click the elephant icon in the toolbar ("Sync Gradle") to ensure that all the correct dependencies are downloaded. (In general, you'll want to do this step any time you update your dependencies.)
-
 ## Run the app from Android Studio
 
-1. Go to Tools > AVD Manager, click "Create Virtual Device...". Then:
+1. Launch Android Studio, and on the welcome screen, select **Plugins** to install the Bazel for Android Studio plugin and restart Android Studio.
 
-   - Select a preferred device definition. In general, any device is fine, but you can use Pixel 3a as a default (if you're developing for phones) or Nexus 7 (if you're developing for tablets). After selecting a device, click "Next" at the bottom right to continue.
-   - Select a system image (in general, API Level 28, unless you're an M1 Mac user, in which case use API Level 29). Then click "Next".
-   - Click "Finish" to complete setup.
+2. On next open, click the options button next to the new project/open project to find the "Import Bazel Project" option.
 
-2. To run the app, select the emulator device you want from the dropdown menu to the left of the "Run" button in the toolbar.
+   <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/efcc4e6e-b6ba-44fc-9c96-aa381de83911" />
 
-3. Finally, click the "Run" button.
+3. A setup wizard will open. For Workspace, click (**...**) to open file manager and select `/opensource/oppia-android` as the location since this is where we have our project's `WORKSPACE` file.
+
+   ![Image](https://github.com/user-attachments/assets/9baf6f71-560b-49fe-84a7-c7b846a64287)
+
+4. On **OK**, you will be asked to **Trust project**. Accept because we trust the project.
+
+   <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/bfc91f6d-d809-418d-ab20-89d899f12f72" />
+
+5. On **next**, to Select Project View, **select Create from scratch**.
+
+   <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/cdc110d6-2926-4f96-b7d8-117e2c716f76" />
+
+6. A file similar to the one below will be generated:
+
+   <img width="760" alt="Image" src="https://github.com/user-attachments/assets/5a26210f-865d-4048-b5a5-73379984bfb5" />
+
+7. In the above file, modify it so that it looks like below(copy and paste):
+   
+   ```
+   directories:
+      # Add the directories you want added as source here
+      # By default, we've added your entire workspace ('.')
+      .
+      
+   # Automatically includes all relevant targets under the 'directories' above
+   derive_targets_from_directories: false
+   
+   targets:
+   # If source code isn't resolving, add additional targets that compile it here
+      //:oppia_dev_binary
+      //app
+      //app/src/main/...
+      //domain/...
+      //model/...
+      //testing/...
+      //utility/...
+      //data/...
+      //scripts/...
path: wiki/Installing-Oppia-Android.md
user: login: adhiamboperes
body: Updated
created_at: 2025-03-14T10:10:57Z
author_association: CONTRIBUTOR
diff_hunk: @@ -63,85 +341,183 @@ Please follow these steps to set up Oppia Android on your local machine.
        5. Download the [google_checks.xml](https://github.com/checkstyle/checkstyle/blob/14005e371803bd52dff429904b354dc3e72638c0/src/main/resources/google_checks.xml) file. To do this, you can simply right-click on the download button at the top-right of the file.
        6. Copy this file to the directory where Git is installed (usually C:/Program Files/Git/).
 
-3. In Android Studio, select `File > Open`, navigate to `opensource/oppia-android/`, and click `OK` to load the project.
-
-4. Select the Compile JDK version
-   - Go to Android Studio > Settings > Build, Execution, Deployment > Build Tools > Gradle
-   - Under "**Gradle JDK**", select Android Studio Default JDK 11.
-   - Then, click "Apply" and "OK" to complete your setup.
-5. Click the elephant icon in the toolbar ("Sync Gradle") to ensure that all the correct dependencies are downloaded. (In general, you'll want to do this step any time you update your dependencies.)
-
 ## Run the app from Android Studio
 
-1. Go to Tools > AVD Manager, click "Create Virtual Device...". Then:
+1. Launch Android Studio, and on the welcome screen, select **Plugins** to install the Bazel for Android Studio plugin and restart Android Studio.
 
-   - Select a preferred device definition. In general, any device is fine, but you can use Pixel 3a as a default (if you're developing for phones) or Nexus 7 (if you're developing for tablets). After selecting a device, click "Next" at the bottom right to continue.
-   - Select a system image (in general, API Level 28, unless you're an M1 Mac user, in which case use API Level 29). Then click "Next".
-   - Click "Finish" to complete setup.
+2. On next open, click the options button next to the new project/open project to find the "Import Bazel Project" option.
 
-2. To run the app, select the emulator device you want from the dropdown menu to the left of the "Run" button in the toolbar.
+   <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/efcc4e6e-b6ba-44fc-9c96-aa381de83911" />
 
-3. Finally, click the "Run" button.
+3. A setup wizard will open. For Workspace, click (**...**) to open file manager and select `/opensource/oppia-android` as the location since this is where we have our project's `WORKSPACE` file.
+
+   ![Image](https://github.com/user-attachments/assets/9baf6f71-560b-49fe-84a7-c7b846a64287)
+
+4. On **OK**, you will be asked to **Trust project**. Accept because we trust the project.
+
+   <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/bfc91f6d-d809-418d-ab20-89d899f12f72" />
+
+5. On **next**, to Select Project View, **select Create from scratch**.
+
+   <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/cdc110d6-2926-4f96-b7d8-117e2c716f76" />
+
+6. A file similar to the one below will be generated:
+
+   <img width="760" alt="Image" src="https://github.com/user-attachments/assets/5a26210f-865d-4048-b5a5-73379984bfb5" />
+
+7. In the above file, modify it so that it looks like below(copy and paste):
+   
+   ```
+   directories:
+      # Add the directories you want added as source here
+      # By default, we've added your entire workspace ('.')
+      .
+      
+   # Automatically includes all relevant targets under the 'directories' above
+   derive_targets_from_directories: false
+   
+   targets:
+   # If source code isn't resolving, add additional targets that compile it here
+      //:oppia_dev_binary
+      //app
+      //app/src/main/...
+      //domain/...
+      //model/...
+      //testing/...
+      //utility/...
+      //data/...
+      //scripts/...
+      
+   additional_languages:
+      # Uncomment any additional languages you want supported
+      # c
+      # dart
+      # kotlin
+      java
+      kotlin
+
+   # Please uncomment an android-SDK platform. Available SDKs are:
+      # android_sdk_platform: android-28
+      android_sdk_platform: android-29
path: wiki/Installing-Oppia-Android.md
user: login: adhiamboperes
body: Updated
created_at: 2025-03-14T10:12:18Z
author_association: CONTRIBUTOR
diff_hunk: @@ -63,85 +341,183 @@ Please follow these steps to set up Oppia Android on your local machine.
        5. Download the [google_checks.xml](https://github.com/checkstyle/checkstyle/blob/14005e371803bd52dff429904b354dc3e72638c0/src/main/resources/google_checks.xml) file. To do this, you can simply right-click on the download button at the top-right of the file.
        6. Copy this file to the directory where Git is installed (usually C:/Program Files/Git/).
 
-3. In Android Studio, select `File > Open`, navigate to `opensource/oppia-android/`, and click `OK` to load the project.
-
-4. Select the Compile JDK version
-   - Go to Android Studio > Settings > Build, Execution, Deployment > Build Tools > Gradle
-   - Under "**Gradle JDK**", select Android Studio Default JDK 11.
-   - Then, click "Apply" and "OK" to complete your setup.
-5. Click the elephant icon in the toolbar ("Sync Gradle") to ensure that all the correct dependencies are downloaded. (In general, you'll want to do this step any time you update your dependencies.)
-
 ## Run the app from Android Studio
 
-1. Go to Tools > AVD Manager, click "Create Virtual Device...". Then:
+1. Launch Android Studio, and on the welcome screen, select **Plugins** to install the Bazel for Android Studio plugin and restart Android Studio.
 
-   - Select a preferred device definition. In general, any device is fine, but you can use Pixel 3a as a default (if you're developing for phones) or Nexus 7 (if you're developing for tablets). After selecting a device, click "Next" at the bottom right to continue.
-   - Select a system image (in general, API Level 28, unless you're an M1 Mac user, in which case use API Level 29). Then click "Next".
-   - Click "Finish" to complete setup.
+2. On next open, click the options button next to the new project/open project to find the "Import Bazel Project" option.
 
-2. To run the app, select the emulator device you want from the dropdown menu to the left of the "Run" button in the toolbar.
+   <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/efcc4e6e-b6ba-44fc-9c96-aa381de83911" />
 
-3. Finally, click the "Run" button.
+3. A setup wizard will open. For Workspace, click (**...**) to open file manager and select `/opensource/oppia-android` as the location since this is where we have our project's `WORKSPACE` file.
+
+   ![Image](https://github.com/user-attachments/assets/9baf6f71-560b-49fe-84a7-c7b846a64287)
+
+4. On **OK**, you will be asked to **Trust project**. Accept because we trust the project.
+
+   <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/bfc91f6d-d809-418d-ab20-89d899f12f72" />
+
+5. On **next**, to Select Project View, **select Create from scratch**.
+
+   <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/cdc110d6-2926-4f96-b7d8-117e2c716f76" />
+
+6. A file similar to the one below will be generated:
+
+   <img width="760" alt="Image" src="https://github.com/user-attachments/assets/5a26210f-865d-4048-b5a5-73379984bfb5" />
+
+7. In the above file, modify it so that it looks like below(copy and paste):
+   
+   ```
+   directories:
+      # Add the directories you want added as source here
+      # By default, we've added your entire workspace ('.')
+      .
+      
+   # Automatically includes all relevant targets under the 'directories' above
+   derive_targets_from_directories: false
+   
+   targets:
+   # If source code isn't resolving, add additional targets that compile it here
+      //:oppia_dev_binary
+      //app
+      //app/src/main/...
+      //domain/...
+      //model/...
+      //testing/...
+      //utility/...
+      //data/...
+      //scripts/...
+      
+   additional_languages:
+      # Uncomment any additional languages you want supported
+      # c
+      # dart
+      # kotlin
+      java
+      kotlin
+
+   # Please uncomment an android-SDK platform. Available SDKs are:
+      # android_sdk_platform: android-28
+      android_sdk_platform: android-29
+      # android_sdk_platform: android-30
+      # android_sdk_platform: android-31
+      # android_sdk_platform: android-32
+      # android_sdk_platform: android-33
+      android_sdk_platform: android-34
+   
+   shard_sync: true
+   sync_flags:
+      --local_ram_resources=HOST_RAM*.5
+      --discard_analysis_cache
path: wiki/Installing-Oppia-Android.md
user: login: adhiamboperes
body: Dropped
created_at: 2025-03-14T10:13:00Z
author_association: CONTRIBUTOR
diff_hunk: @@ -63,85 +341,183 @@ Please follow these steps to set up Oppia Android on your local machine.
        5. Download the [google_checks.xml](https://github.com/checkstyle/checkstyle/blob/14005e371803bd52dff429904b354dc3e72638c0/src/main/resources/google_checks.xml) file. To do this, you can simply right-click on the download button at the top-right of the file.
        6. Copy this file to the directory where Git is installed (usually C:/Program Files/Git/).
 
-3. In Android Studio, select `File > Open`, navigate to `opensource/oppia-android/`, and click `OK` to load the project.
-
-4. Select the Compile JDK version
-   - Go to Android Studio > Settings > Build, Execution, Deployment > Build Tools > Gradle
-   - Under "**Gradle JDK**", select Android Studio Default JDK 11.
-   - Then, click "Apply" and "OK" to complete your setup.
-5. Click the elephant icon in the toolbar ("Sync Gradle") to ensure that all the correct dependencies are downloaded. (In general, you'll want to do this step any time you update your dependencies.)
-
 ## Run the app from Android Studio
 
-1. Go to Tools > AVD Manager, click "Create Virtual Device...". Then:
+1. Launch Android Studio, and on the welcome screen, select **Plugins** to install the Bazel for Android Studio plugin and restart Android Studio.
 
-   - Select a preferred device definition. In general, any device is fine, but you can use Pixel 3a as a default (if you're developing for phones) or Nexus 7 (if you're developing for tablets). After selecting a device, click "Next" at the bottom right to continue.
-   - Select a system image (in general, API Level 28, unless you're an M1 Mac user, in which case use API Level 29). Then click "Next".
-   - Click "Finish" to complete setup.
+2. On next open, click the options button next to the new project/open project to find the "Import Bazel Project" option.
 
-2. To run the app, select the emulator device you want from the dropdown menu to the left of the "Run" button in the toolbar.
+   <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/efcc4e6e-b6ba-44fc-9c96-aa381de83911" />
 
-3. Finally, click the "Run" button.
+3. A setup wizard will open. For Workspace, click (**...**) to open file manager and select `/opensource/oppia-android` as the location since this is where we have our project's `WORKSPACE` file.
+
+   ![Image](https://github.com/user-attachments/assets/9baf6f71-560b-49fe-84a7-c7b846a64287)
+
+4. On **OK**, you will be asked to **Trust project**. Accept because we trust the project.
+
+   <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/bfc91f6d-d809-418d-ab20-89d899f12f72" />
+
+5. On **next**, to Select Project View, **select Create from scratch**.
+
+   <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/cdc110d6-2926-4f96-b7d8-117e2c716f76" />
+
+6. A file similar to the one below will be generated:
+
+   <img width="760" alt="Image" src="https://github.com/user-attachments/assets/5a26210f-865d-4048-b5a5-73379984bfb5" />
+
+7. In the above file, modify it so that it looks like below(copy and paste):
+   
+   ```
+   directories:
+      # Add the directories you want added as source here
+      # By default, we've added your entire workspace ('.')
+      .
+      
+   # Automatically includes all relevant targets under the 'directories' above
+   derive_targets_from_directories: false
+   
+   targets:
+   # If source code isn't resolving, add additional targets that compile it here
+      //:oppia_dev_binary
+      //app
+      //app/src/main/...
+      //domain/...
+      //model/...
+      //testing/...
+      //utility/...
+      //data/...
+      //scripts/...
+      
+   additional_languages:
+      # Uncomment any additional languages you want supported
+      # c
+      # dart
+      # kotlin
+      java
+      kotlin
+
+   # Please uncomment an android-SDK platform. Available SDKs are:
+      # android_sdk_platform: android-28
+      android_sdk_platform: android-29
+      # android_sdk_platform: android-30
+      # android_sdk_platform: android-31
+      # android_sdk_platform: android-32
+      # android_sdk_platform: android-33
+      android_sdk_platform: android-34
+   
+   shard_sync: true
+   sync_flags:
+      --local_ram_resources=HOST_RAM*.5
+      --discard_analysis_cache
+   
+   java_language_level: 11
+   ```
+   **Note**: Only enable Android-SDK platforms that you have installed per the [Prepare developer environment](#prepare-developer-environment) section above. Android-SDK platforms are useful for creating emulators to test your app with.
+
+8. Click **Create**, and allow the project to synchronize.
+
+9. Once sync has finished, you can now build and install the app on either a virtual or physical device. Bazel supports deploying to only one device at a time, so you can connect one device, or launch one emulator at a time.
+
+   You can run the project by using the Bazel plugin to set up run configurations for the target that you wish to build. This performs the same action as the commands below, but using the GUI to run the app might be more intuitive for some developers.
+
+   ![Screenshot 2025-02-26 at 22 16 32](https://github.com/user-attachments/assets/f3be5288-dc96-4079-bcb2-b514de81f899)
+
+   Edit configurations allows us to specify the run command:
+
+   ![Image](https://github.com/user-attachments/assets/7270b6b3-11ac-4b49-a39a-734e0437bb9e)
+
+     - Target **Name**, is helpful for identifying the target from the list on the left.
+     - **Target expression** requires a build target such as `//:oppia_dev_binary`.
+     - **The Bazel command** is `mobile-install`
+     - **Bazel flags** are optional.
+     - Select **Apply** and then **Close** or **Ok**.
+
+## Run the app from the command line
path: wiki/Installing-Oppia-Android.md
user: login: adhiamboperes
body: Moved to the user guide and included the link above.
created_at: 2025-03-14T10:27:49Z
author_association: CONTRIBUTOR
diff_hunk: @@ -63,85 +341,183 @@ Please follow these steps to set up Oppia Android on your local machine.
        5. Download the [google_checks.xml](https://github.com/checkstyle/checkstyle/blob/14005e371803bd52dff429904b354dc3e72638c0/src/main/resources/google_checks.xml) file. To do this, you can simply right-click on the download button at the top-right of the file.
        6. Copy this file to the directory where Git is installed (usually C:/Program Files/Git/).
 
-3. In Android Studio, select `File > Open`, navigate to `opensource/oppia-android/`, and click `OK` to load the project.
-
-4. Select the Compile JDK version
-   - Go to Android Studio > Settings > Build, Execution, Deployment > Build Tools > Gradle
-   - Under "**Gradle JDK**", select Android Studio Default JDK 11.
-   - Then, click "Apply" and "OK" to complete your setup.
-5. Click the elephant icon in the toolbar ("Sync Gradle") to ensure that all the correct dependencies are downloaded. (In general, you'll want to do this step any time you update your dependencies.)
-
 ## Run the app from Android Studio
 
-1. Go to Tools > AVD Manager, click "Create Virtual Device...". Then:
+1. Launch Android Studio, and on the welcome screen, select **Plugins** to install the Bazel for Android Studio plugin and restart Android Studio.
 
-   - Select a preferred device definition. In general, any device is fine, but you can use Pixel 3a as a default (if you're developing for phones) or Nexus 7 (if you're developing for tablets). After selecting a device, click "Next" at the bottom right to continue.
-   - Select a system image (in general, API Level 28, unless you're an M1 Mac user, in which case use API Level 29). Then click "Next".
-   - Click "Finish" to complete setup.
+2. On next open, click the options button next to the new project/open project to find the "Import Bazel Project" option.
 
-2. To run the app, select the emulator device you want from the dropdown menu to the left of the "Run" button in the toolbar.
+   <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/efcc4e6e-b6ba-44fc-9c96-aa381de83911" />
 
-3. Finally, click the "Run" button.
+3. A setup wizard will open. For Workspace, click (**...**) to open file manager and select `/opensource/oppia-android` as the location since this is where we have our project's `WORKSPACE` file.
+
+   ![Image](https://github.com/user-attachments/assets/9baf6f71-560b-49fe-84a7-c7b846a64287)
+
+4. On **OK**, you will be asked to **Trust project**. Accept because we trust the project.
+
+   <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/bfc91f6d-d809-418d-ab20-89d899f12f72" />
+
+5. On **next**, to Select Project View, **select Create from scratch**.
+
+   <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/cdc110d6-2926-4f96-b7d8-117e2c716f76" />
+
+6. A file similar to the one below will be generated:
+
+   <img width="760" alt="Image" src="https://github.com/user-attachments/assets/5a26210f-865d-4048-b5a5-73379984bfb5" />
+
+7. In the above file, modify it so that it looks like below(copy and paste):
+   
+   ```
+   directories:
+      # Add the directories you want added as source here
+      # By default, we've added your entire workspace ('.')
+      .
+      
+   # Automatically includes all relevant targets under the 'directories' above
+   derive_targets_from_directories: false
+   
+   targets:
+   # If source code isn't resolving, add additional targets that compile it here
+      //:oppia_dev_binary
+      //app
+      //app/src/main/...
+      //domain/...
+      //model/...
+      //testing/...
+      //utility/...
+      //data/...
+      //scripts/...
+      
+   additional_languages:
+      # Uncomment any additional languages you want supported
+      # c
+      # dart
+      # kotlin
+      java
+      kotlin
+
+   # Please uncomment an android-SDK platform. Available SDKs are:
+      # android_sdk_platform: android-28
+      android_sdk_platform: android-29
+      # android_sdk_platform: android-30
+      # android_sdk_platform: android-31
+      # android_sdk_platform: android-32
+      # android_sdk_platform: android-33
+      android_sdk_platform: android-34
+   
+   shard_sync: true
+   sync_flags:
+      --local_ram_resources=HOST_RAM*.5
+      --discard_analysis_cache
+   
+   java_language_level: 11
+   ```
+   **Note**: Only enable Android-SDK platforms that you have installed per the [Prepare developer environment](#prepare-developer-environment) section above. Android-SDK platforms are useful for creating emulators to test your app with.
+
+8. Click **Create**, and allow the project to synchronize.
+
+9. Once sync has finished, you can now build and install the app on either a virtual or physical device. Bazel supports deploying to only one device at a time, so you can connect one device, or launch one emulator at a time.
+
+   You can run the project by using the Bazel plugin to set up run configurations for the target that you wish to build. This performs the same action as the commands below, but using the GUI to run the app might be more intuitive for some developers.
+
+   ![Screenshot 2025-02-26 at 22 16 32](https://github.com/user-attachments/assets/f3be5288-dc96-4079-bcb2-b514de81f899)
+
+   Edit configurations allows us to specify the run command:
+
+   ![Image](https://github.com/user-attachments/assets/7270b6b3-11ac-4b49-a39a-734e0437bb9e)
+
+     - Target **Name**, is helpful for identifying the target from the list on the left.
+     - **Target expression** requires a build target such as `//:oppia_dev_binary`.
+     - **The Bazel command** is `mobile-install`
+     - **Bazel flags** are optional.
+     - Select **Apply** and then **Close** or **Ok**.
+
+## Run the app from the command line
+
+Using the command line is helpful in instances when you need to run some targets outside of Android Studio.
+
+Run the following commands in your terminal. All Bazel commands must be run from the root of the ‘oppia-android’ directory otherwise they will fail.
+
+Note that on the first run, these commands may take 10-20 minutes to complete depending on the performance of your machine. Subsequent runs will be much faster.
+
+On Sdk 29 and below, run:
+   ```
+   bazel mobile-install //:oppia_dev_binary
+   ```
+This will build, install and launch the app on your device.
+
+On Sdk 30 and newer, run:
+   ```
+   bazel build //:oppia_dev
+   ```
+followed by:
+   ```
+   adb install bazel-bin/oppia_dev_binary.apk  
+   ```
+Starting from Sdk 30, incremental builds, like those executed using `bazel mobile-install`, are no longer permitted, necessitating the use of two separate commands.
+
+If everything is working, you should see output like the following:
+
+```
+Target //:oppia_dev up-to-date:
+  bazel-bin/oppia_dev.aab
+INFO: Elapsed time: ...
+INFO: 1 process...
+INFO: Build completed successfully, ...
+```
+
+Note also that the ``oppia_dev.aab`` under the ``bazel-bin`` directory of your local copy of Oppia Android should be a fully functioning development version of the app that can be installed using bundle-tool. However, it's recommended to deploy Oppia to an emulator or connected device using the `mobile-install` command.
 
 ## Set up and run tests
 Testing the app is an integral part of our development process. You will need to test all code changes to ensure that the app works correctly, therefore it is important to ensure that your test configuration works.
 
-We strongly recommend running tests on Robolectric which is faster because it does not require a physical device or emulator setup.
+Our Bazel setup currently supports running tests on Robolectric which is fast because it does not require a physical device or emulator setup.
 
-### Configure Robolectric Tests
+We can run tests either through the UI supported by the Bazel Plugin, or via running a `bazel test` command on the terminal, i.e.:
 
-#### Step-by-Step guidance for setting up and running app modules robolectric test:
+> Tip 1: In order to get the correct path always, open the test file, then on the AS sidebar, right click on the file, and select `copy path/reference`. Then select `copy path from repository root`. Paste the copied path to terminal and remove the `.kt` extension.
 
-1. Go to **Edit Configuration** in Android Studio (Bumblebee | 2021.1.1 Patch 3)
-   ![](https://user-images.githubusercontent.com/9396084/79109714-83525980-7d96-11ea-99d7-f83ea81a8a50.png)
+   ```
+   bazel test full-path-of-test-file
+   ```
 
-2. Click on Add(+) -> **JUnit**
-   ![](https://github.com/oppia/oppia-android/assets/76530270/87caf3fc-37d9-472d-92fd-b8ec49fb6b49)
+e.g.
+   
+   ```
+   bazel test domain/src/test/java/org/oppia/android/domain/onboarding/AppStartupStateControllerTest
+   ```
 
-3. Enter following information:
-   - a) Name of test. Example: In my case "SplashActivityTest"
-   - b) Make sure select "java 11" and oppia-android.app
-   - c) Class path of Test class. Example: In my case "org.oppia.android.app.splash.
-   SplashActivityTest"
-   - d) Press `OK` to select the test.
-   ![](https://github.com/oppia/oppia-android/assets/76530270/5901624a-df76-4b27-8f31-6077a68fcb89)
+> Tip 2: You can pass a target argument to the `bazel test` command instead. Copy the relative path to the test file and query its target using `bazel query path-of-test-file` e.g. `bazel query domain/src/test/java/org/oppia/android/domain/onboarding/AppStartupStateControllerTest.kt`. This will give you a Bazel target (i.e. starts with '//') --just copy that and remove the `.kt` at the end and you can pass it to `bazel test`, e.g.
 
-4. Click on "Run" button to run robolectric test. (In my case "SplashActivityTest")
-   ![](https://github.com/oppia/oppia-android/assets/76530270/75a6b998-90c5-4f0a-8886-78f96970be90)
+```
+bazel test //domain/src/test/java/org/oppia/android/domain/onboarding:AppStartupStateControllerTest
+```
 
-#### For tests that are in non-app modules, such as **domain** or **utility**::
+### Configure Robolectric Tests
path: wiki/Installing-Oppia-Android.md
user: login: adhiamboperes
body: The whole setting up tests section?
created_at: 2025-03-14T10:29:24Z
author_association: CONTRIBUTOR
diff_hunk: @@ -63,85 +341,183 @@ Please follow these steps to set up Oppia Android on your local machine.
        5. Download the [google_checks.xml](https://github.com/checkstyle/checkstyle/blob/14005e371803bd52dff429904b354dc3e72638c0/src/main/resources/google_checks.xml) file. To do this, you can simply right-click on the download button at the top-right of the file.
        6. Copy this file to the directory where Git is installed (usually C:/Program Files/Git/).
 
-3. In Android Studio, select `File > Open`, navigate to `opensource/oppia-android/`, and click `OK` to load the project.
-
-4. Select the Compile JDK version
-   - Go to Android Studio > Settings > Build, Execution, Deployment > Build Tools > Gradle
-   - Under "**Gradle JDK**", select Android Studio Default JDK 11.
-   - Then, click "Apply" and "OK" to complete your setup.
-5. Click the elephant icon in the toolbar ("Sync Gradle") to ensure that all the correct dependencies are downloaded. (In general, you'll want to do this step any time you update your dependencies.)
-
 ## Run the app from Android Studio
 
-1. Go to Tools > AVD Manager, click "Create Virtual Device...". Then:
+1. Launch Android Studio, and on the welcome screen, select **Plugins** to install the Bazel for Android Studio plugin and restart Android Studio.
 
-   - Select a preferred device definition. In general, any device is fine, but you can use Pixel 3a as a default (if you're developing for phones) or Nexus 7 (if you're developing for tablets). After selecting a device, click "Next" at the bottom right to continue.
-   - Select a system image (in general, API Level 28, unless you're an M1 Mac user, in which case use API Level 29). Then click "Next".
-   - Click "Finish" to complete setup.
+2. On next open, click the options button next to the new project/open project to find the "Import Bazel Project" option.
 
-2. To run the app, select the emulator device you want from the dropdown menu to the left of the "Run" button in the toolbar.
+   <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/efcc4e6e-b6ba-44fc-9c96-aa381de83911" />
 
-3. Finally, click the "Run" button.
+3. A setup wizard will open. For Workspace, click (**...**) to open file manager and select `/opensource/oppia-android` as the location since this is where we have our project's `WORKSPACE` file.
+
+   ![Image](https://github.com/user-attachments/assets/9baf6f71-560b-49fe-84a7-c7b846a64287)
+
+4. On **OK**, you will be asked to **Trust project**. Accept because we trust the project.
+
+   <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/bfc91f6d-d809-418d-ab20-89d899f12f72" />
+
+5. On **next**, to Select Project View, **select Create from scratch**.
+
+   <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/cdc110d6-2926-4f96-b7d8-117e2c716f76" />
+
+6. A file similar to the one below will be generated:
+
+   <img width="760" alt="Image" src="https://github.com/user-attachments/assets/5a26210f-865d-4048-b5a5-73379984bfb5" />
+
+7. In the above file, modify it so that it looks like below(copy and paste):
+   
+   ```
+   directories:
+      # Add the directories you want added as source here
+      # By default, we've added your entire workspace ('.')
+      .
+      
+   # Automatically includes all relevant targets under the 'directories' above
+   derive_targets_from_directories: false
+   
+   targets:
+   # If source code isn't resolving, add additional targets that compile it here
+      //:oppia_dev_binary
+      //app
+      //app/src/main/...
+      //domain/...
+      //model/...
+      //testing/...
+      //utility/...
+      //data/...
+      //scripts/...
+      
+   additional_languages:
+      # Uncomment any additional languages you want supported
+      # c
+      # dart
+      # kotlin
+      java
+      kotlin
+
+   # Please uncomment an android-SDK platform. Available SDKs are:
+      # android_sdk_platform: android-28
+      android_sdk_platform: android-29
+      # android_sdk_platform: android-30
+      # android_sdk_platform: android-31
+      # android_sdk_platform: android-32
+      # android_sdk_platform: android-33
+      android_sdk_platform: android-34
+   
+   shard_sync: true
+   sync_flags:
+      --local_ram_resources=HOST_RAM*.5
+      --discard_analysis_cache
+   
+   java_language_level: 11
+   ```
+   **Note**: Only enable Android-SDK platforms that you have installed per the [Prepare developer environment](#prepare-developer-environment) section above. Android-SDK platforms are useful for creating emulators to test your app with.
+
+8. Click **Create**, and allow the project to synchronize.
+
+9. Once sync has finished, you can now build and install the app on either a virtual or physical device. Bazel supports deploying to only one device at a time, so you can connect one device, or launch one emulator at a time.
+
+   You can run the project by using the Bazel plugin to set up run configurations for the target that you wish to build. This performs the same action as the commands below, but using the GUI to run the app might be more intuitive for some developers.
+
+   ![Screenshot 2025-02-26 at 22 16 32](https://github.com/user-attachments/assets/f3be5288-dc96-4079-bcb2-b514de81f899)
+
+   Edit configurations allows us to specify the run command:
+
+   ![Image](https://github.com/user-attachments/assets/7270b6b3-11ac-4b49-a39a-734e0437bb9e)
+
+     - Target **Name**, is helpful for identifying the target from the list on the left.
+     - **Target expression** requires a build target such as `//:oppia_dev_binary`.
+     - **The Bazel command** is `mobile-install`
+     - **Bazel flags** are optional.
+     - Select **Apply** and then **Close** or **Ok**.
+
+## Run the app from the command line
+
+Using the command line is helpful in instances when you need to run some targets outside of Android Studio.
+
+Run the following commands in your terminal. All Bazel commands must be run from the root of the ‘oppia-android’ directory otherwise they will fail.
+
+Note that on the first run, these commands may take 10-20 minutes to complete depending on the performance of your machine. Subsequent runs will be much faster.
+
+On Sdk 29 and below, run:
+   ```
+   bazel mobile-install //:oppia_dev_binary
+   ```
+This will build, install and launch the app on your device.
+
+On Sdk 30 and newer, run:
+   ```
+   bazel build //:oppia_dev
+   ```
+followed by:
+   ```
+   adb install bazel-bin/oppia_dev_binary.apk  
+   ```
+Starting from Sdk 30, incremental builds, like those executed using `bazel mobile-install`, are no longer permitted, necessitating the use of two separate commands.
+
+If everything is working, you should see output like the following:
+
+```
+Target //:oppia_dev up-to-date:
+  bazel-bin/oppia_dev.aab
+INFO: Elapsed time: ...
+INFO: 1 process...
+INFO: Build completed successfully, ...
+```
+
+Note also that the ``oppia_dev.aab`` under the ``bazel-bin`` directory of your local copy of Oppia Android should be a fully functioning development version of the app that can be installed using bundle-tool. However, it's recommended to deploy Oppia to an emulator or connected device using the `mobile-install` command.
 
 ## Set up and run tests
 Testing the app is an integral part of our development process. You will need to test all code changes to ensure that the app works correctly, therefore it is important to ensure that your test configuration works.
 
-We strongly recommend running tests on Robolectric which is faster because it does not require a physical device or emulator setup.
+Our Bazel setup currently supports running tests on Robolectric which is fast because it does not require a physical device or emulator setup.
 
-### Configure Robolectric Tests
+We can run tests either through the UI supported by the Bazel Plugin, or via running a `bazel test` command on the terminal, i.e.:
 
-#### Step-by-Step guidance for setting up and running app modules robolectric test:
+> Tip 1: In order to get the correct path always, open the test file, then on the AS sidebar, right click on the file, and select `copy path/reference`. Then select `copy path from repository root`. Paste the copied path to terminal and remove the `.kt` extension.
 
-1. Go to **Edit Configuration** in Android Studio (Bumblebee | 2021.1.1 Patch 3)
-   ![](https://user-images.githubusercontent.com/9396084/79109714-83525980-7d96-11ea-99d7-f83ea81a8a50.png)
+   ```
+   bazel test full-path-of-test-file
+   ```
 
-2. Click on Add(+) -> **JUnit**
-   ![](https://github.com/oppia/oppia-android/assets/76530270/87caf3fc-37d9-472d-92fd-b8ec49fb6b49)
+e.g.
+   
+   ```
+   bazel test domain/src/test/java/org/oppia/android/domain/onboarding/AppStartupStateControllerTest
+   ```
 
-3. Enter following information:
-   - a) Name of test. Example: In my case "SplashActivityTest"
-   - b) Make sure select "java 11" and oppia-android.app
-   - c) Class path of Test class. Example: In my case "org.oppia.android.app.splash.
-   SplashActivityTest"
-   - d) Press `OK` to select the test.
-   ![](https://github.com/oppia/oppia-android/assets/76530270/5901624a-df76-4b27-8f31-6077a68fcb89)
+> Tip 2: You can pass a target argument to the `bazel test` command instead. Copy the relative path to the test file and query its target using `bazel query path-of-test-file` e.g. `bazel query domain/src/test/java/org/oppia/android/domain/onboarding/AppStartupStateControllerTest.kt`. This will give you a Bazel target (i.e. starts with '//') --just copy that and remove the `.kt` at the end and you can pass it to `bazel test`, e.g.
 
-4. Click on "Run" button to run robolectric test. (In my case "SplashActivityTest")
-   ![](https://github.com/oppia/oppia-android/assets/76530270/75a6b998-90c5-4f0a-8886-78f96970be90)
+```
+bazel test //domain/src/test/java/org/oppia/android/domain/onboarding:AppStartupStateControllerTest
+```
 
-#### For tests that are in non-app modules, such as **domain** or **utility**::
+### Configure Robolectric Tests
+
+#### Step-by-Step guidance for setting up and running app module robolectric tests:
 
-1. In Android Studio, open the desired test file, e.g., `AnalyticsControllerTest`.
-2. In the test file, to the left of the class name, click on the orange and green arrow, and select **Run 'AnalyticsControllerTest'**.
-   - You will notice that the emulator is greyed out, but the run window will open to show the running tests:
-   ![](https://user-images.githubusercontent.com/59600948/272657015-158117e5-47d2-40fc-a38b-5dee6c347556.png)
+1. In Android Studio, open the test file that you wish to run. If sync completed successfully when the project was opened, there will be a green run arrow next to the class name, as well as next to each individual test name. Clicking on the arrow will run either the full class or a single test as selected.
 
-### Configure Emulator Tests
+2. Because we have set up the Bazel plugin, we can also run a test class using the run arrow at the top of the project window:
 
-**Espresso is slower for running tests, so we recommend using Robolectric.**
+   ![Screenshot 2025-02-26 at 22 16 32](https://github.com/user-attachments/assets/f3be5288-dc96-4079-bcb2-b514de81f899)
 
-1. In Android Studio, open the desired test file, e.g., `HomeActivityTest`.
-2. In the Android Studio toolbar, click on the `Available Devices` option. Select an emulator that has between API 28-30.
+   Edit configurations allows us to specify the run command:
+   ![Screenshot 2025-02-26 at 22 19 34](https://github.com/user-attachments/assets/462d07d2-4407-4898-bbc4-544509bd7486)
 
-   **Note**: If you don't have any available devices in this list, please follow [these instructions](#run-the-app-from-android-studio) to create one.
+   - Test **name**, is helpful for identifying the test target from the list on the left.
+   - **Target expression** requires the fully qualified path to the test file.
+   - **The Bazel command** for running tests is `test`
+   - **Bazel flags** are optional.
+   - Select **Apply** and then **Close** or **Ok**.
 
-3. In the test file, to the left of the class name, click on the orange and green arrow, and select **Run 'HomeActivityTest'**.
-   ![](https://user-images.githubusercontent.com/59600948/272657131-96e5354b-13a9-4709-969a-b9494a65c30f.png)
+#### For tests that are in non-app modules, such as **domain** or **utility**::
path: wiki/Installing-Oppia-Android.md
user: login: adhiamboperes
body: These are covered under `Set up and run tests` tips above.
created_at: 2025-03-14T10:37:06Z
author_association: CONTRIBUTOR
diff_hunk: @@ -150,8 +526,95 @@ We strongly recommend running tests on Robolectric which is faster because it do
 
 - To learn about how we write tests at oppia-android, please refer to: [Oppia Android Testing](https://github.com/oppia/oppia-android/wiki/Oppia-Android-Testing).
 
-- To get started with Bazel, please see [Oppia-Bazel-Setup-Instructions](https://github.com/oppia/oppia-android/wiki/Oppia-Bazel-Setup-Instructions) and follow the instructions appropriate to your OS.
-
-- If you run into any issues during your setup, search our [discussions](https://github.com/oppia/oppia-android/discussions) forum or start a new discussion.
-
-- Please see  [Troubleshooting-Installation](https://github.com/oppia/oppia-android/wiki/Troubleshooting-Installation) for solutions to some common setup issues.
+- To learn more about getting started with Bazel, please see [Oppia-Bazel-Glossary](https://github.com/oppia/oppia-android/wiki/Oppia-Bazel-Glossary).
+
+### Troubleshooting Installation
+#### General issues
+1. If the Static Checks on your PR keeps failing, please refer to [instructions on running static checks locally](https://github.com/oppia/oppia-android/wiki/Static-Analysis-Checks#how-to-run-static-checks-locally) in order to catch these errors before pushing.
+2. If you are using Android Studio or another UI-based git to push, you might see unclear errors such as `Error: Failed to push some refs to git@github.com:<your_user_name>/oppia-android.git`. We recommend using the command line to run all git commands.
+
+#### Bazel issues
+The team is in the process of migrating away from Gradle to Bazel, so while the project still has Gradle build files, they are no longer maintained and cannot be used to build the project.
+
+Please note that:
+- It's currently recommended that all team members use **Bazel** for their active development in Android Studio. While some team members use the Bazel Android Studio plugin, day-to-day Bazel development currently suffers from:
path: wiki/Installing-Oppia-Android.md
user: login: adhiamboperes
body: Updated
created_at: 2025-03-14T10:40:31Z
author_association: CONTRIBUTOR
diff_hunk: @@ -150,8 +526,95 @@ We strongly recommend running tests on Robolectric which is faster because it do
 
 - To learn about how we write tests at oppia-android, please refer to: [Oppia Android Testing](https://github.com/oppia/oppia-android/wiki/Oppia-Android-Testing).
 
-- To get started with Bazel, please see [Oppia-Bazel-Setup-Instructions](https://github.com/oppia/oppia-android/wiki/Oppia-Bazel-Setup-Instructions) and follow the instructions appropriate to your OS.
-
-- If you run into any issues during your setup, search our [discussions](https://github.com/oppia/oppia-android/discussions) forum or start a new discussion.
-
-- Please see  [Troubleshooting-Installation](https://github.com/oppia/oppia-android/wiki/Troubleshooting-Installation) for solutions to some common setup issues.
+- To learn more about getting started with Bazel, please see [Oppia-Bazel-Glossary](https://github.com/oppia/oppia-android/wiki/Oppia-Bazel-Glossary).
+
+### Troubleshooting Installation
+#### General issues
+1. If the Static Checks on your PR keeps failing, please refer to [instructions on running static checks locally](https://github.com/oppia/oppia-android/wiki/Static-Analysis-Checks#how-to-run-static-checks-locally) in order to catch these errors before pushing.
+2. If you are using Android Studio or another UI-based git to push, you might see unclear errors such as `Error: Failed to push some refs to git@github.com:<your_user_name>/oppia-android.git`. We recommend using the command line to run all git commands.
+
+#### Bazel issues
+The team is in the process of migrating away from Gradle to Bazel, so while the project still has Gradle build files, they are no longer maintained and cannot be used to build the project.
+
+Please note that:
+- It's currently recommended that all team members use **Bazel** for their active development in Android Studio. While some team members use the Bazel Android Studio plugin, day-to-day Bazel development currently suffers from:
+    - Significant memory overhead that continues to grow without careful pruning (i.e. periodic shutdowns of the local Bazel build server). On some Linux distros or MacOS, this can result in a Kernel panic when memory is fully exhausted.
+    - Various symbolic errors throughout the codebase that can make it much more difficult to jump to specific symbols (though, unlike Gradle, all code including scripts are editable and runnable within Android Studio).
+    - Syntax highlighting errors in some instances.
+- As the team finishes the migration to Bazel, communications and instructions will be sent ahead of time, and we will continually update our documentation with the latest changes.
+
+1. No matching toolchains (sdk_toolchain_type)
path: wiki/Installing-Oppia-Android.md
user: login: adhiamboperes
body: Done
created_at: 2025-03-14T10:41:19Z
author_association: CONTRIBUTOR
diff_hunk: @@ -63,85 +341,183 @@ Please follow these steps to set up Oppia Android on your local machine.
        5. Download the [google_checks.xml](https://github.com/checkstyle/checkstyle/blob/14005e371803bd52dff429904b354dc3e72638c0/src/main/resources/google_checks.xml) file. To do this, you can simply right-click on the download button at the top-right of the file.
        6. Copy this file to the directory where Git is installed (usually C:/Program Files/Git/).
 
-3. In Android Studio, select `File > Open`, navigate to `opensource/oppia-android/`, and click `OK` to load the project.
-
-4. Select the Compile JDK version
-   - Go to Android Studio > Settings > Build, Execution, Deployment > Build Tools > Gradle
-   - Under "**Gradle JDK**", select Android Studio Default JDK 11.
-   - Then, click "Apply" and "OK" to complete your setup.
-5. Click the elephant icon in the toolbar ("Sync Gradle") to ensure that all the correct dependencies are downloaded. (In general, you'll want to do this step any time you update your dependencies.)
-
 ## Run the app from Android Studio
 
-1. Go to Tools > AVD Manager, click "Create Virtual Device...". Then:
+1. Launch Android Studio, and on the welcome screen, select **Plugins** to install the Bazel for Android Studio plugin and restart Android Studio.
 
-   - Select a preferred device definition. In general, any device is fine, but you can use Pixel 3a as a default (if you're developing for phones) or Nexus 7 (if you're developing for tablets). After selecting a device, click "Next" at the bottom right to continue.
-   - Select a system image (in general, API Level 28, unless you're an M1 Mac user, in which case use API Level 29). Then click "Next".
-   - Click "Finish" to complete setup.
+2. On next open, click the options button next to the new project/open project to find the "Import Bazel Project" option.
 
-2. To run the app, select the emulator device you want from the dropdown menu to the left of the "Run" button in the toolbar.
+   <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/efcc4e6e-b6ba-44fc-9c96-aa381de83911" />
 
-3. Finally, click the "Run" button.
+3. A setup wizard will open. For Workspace, click (**...**) to open file manager and select `/opensource/oppia-android` as the location since this is where we have our project's `WORKSPACE` file.
+
+   ![Image](https://github.com/user-attachments/assets/9baf6f71-560b-49fe-84a7-c7b846a64287)
+
+4. On **OK**, you will be asked to **Trust project**. Accept because we trust the project.
+
+   <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/bfc91f6d-d809-418d-ab20-89d899f12f72" />
+
+5. On **next**, to Select Project View, **select Create from scratch**.
+
+   <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/cdc110d6-2926-4f96-b7d8-117e2c716f76" />
+
+6. A file similar to the one below will be generated:
+
+   <img width="760" alt="Image" src="https://github.com/user-attachments/assets/5a26210f-865d-4048-b5a5-73379984bfb5" />
+
+7. In the above file, modify it so that it looks like below(copy and paste):
+   
+   ```
+   directories:
+      # Add the directories you want added as source here
+      # By default, we've added your entire workspace ('.')
+      .
+      
+   # Automatically includes all relevant targets under the 'directories' above
+   derive_targets_from_directories: false
+   
+   targets:
+   # If source code isn't resolving, add additional targets that compile it here
+      //:oppia_dev_binary
+      //app
+      //app/src/main/...
+      //domain/...
+      //model/...
+      //testing/...
+      //utility/...
+      //data/...
+      //scripts/...
+      
+   additional_languages:
+      # Uncomment any additional languages you want supported
+      # c
+      # dart
+      # kotlin
+      java
+      kotlin
+
+   # Please uncomment an android-SDK platform. Available SDKs are:
+      # android_sdk_platform: android-28
+      android_sdk_platform: android-29
+      # android_sdk_platform: android-30
+      # android_sdk_platform: android-31
+      # android_sdk_platform: android-32
+      # android_sdk_platform: android-33
+      android_sdk_platform: android-34
+   
+   shard_sync: true
+   sync_flags:
+      --local_ram_resources=HOST_RAM*.5
+      --discard_analysis_cache
+   
+   java_language_level: 11
+   ```
+   **Note**: Only enable Android-SDK platforms that you have installed per the [Prepare developer environment](#prepare-developer-environment) section above. Android-SDK platforms are useful for creating emulators to test your app with.
+
+8. Click **Create**, and allow the project to synchronize.
+
+9. Once sync has finished, you can now build and install the app on either a virtual or physical device. Bazel supports deploying to only one device at a time, so you can connect one device, or launch one emulator at a time.
+
+   You can run the project by using the Bazel plugin to set up run configurations for the target that you wish to build. This performs the same action as the commands below, but using the GUI to run the app might be more intuitive for some developers.
path: wiki/Installing-Oppia-Android.md
user: login: adhiamboperes
body: Should be solved when https://github.com/oppia/oppia-android/issues/5761 is addressed
created_at: 2025-03-14T10:57:18Z
author_association: CONTRIBUTOR
diff_hunk: @@ -3,60 +3,53 @@
 - [Overview](#overview)
 - [Installation](#installation)
   - [Building the app](#building-the-app)
-  - [Building + installing the app](#building--installing-the-app)
   - [Running specific module (app) Robolectric tests](#running-specific-module-app-robolectric-tests)
   - [Running all Robolectric tests (slow)](#running-all-robolectric-tests-slow)
-- [Known Issues and Troubleshooting](#known-issues-and-troubleshooting)
 - [Concepts and Terminology](#concepts-and-terminology)
+- [Syncing the Project](#syncing-the-project)
 
 ## Overview
 Bazel is an open-source build and test tool similar to Make, Maven, and Gradle. It uses a human-readable, high-level build language.
 
 **WARNING: We recommend to not use the Android Studio Bazel plugin since it currently has compatibility issues with the project.**
path: wiki/Oppia-Bazel-Glossary.md
user: login: adhiamboperes
body: Done.
created_at: 2025-03-14T10:59:13Z
author_association: CONTRIBUTOR
diff_hunk: @@ -3,60 +3,53 @@
 - [Overview](#overview)
 - [Installation](#installation)
   - [Building the app](#building-the-app)
-  - [Building + installing the app](#building--installing-the-app)
   - [Running specific module (app) Robolectric tests](#running-specific-module-app-robolectric-tests)
   - [Running all Robolectric tests (slow)](#running-all-robolectric-tests-slow)
-- [Known Issues and Troubleshooting](#known-issues-and-troubleshooting)
 - [Concepts and Terminology](#concepts-and-terminology)
+- [Syncing the Project](#syncing-the-project)
 
 ## Overview
 Bazel is an open-source build and test tool similar to Make, Maven, and Gradle. It uses a human-readable, high-level build language.
 
 **WARNING: We recommend to not use the Android Studio Bazel plugin since it currently has compatibility issues with the project.**
 
-### Installation
+## Installation
 
-1. Download and Install Java 11 using the links from the [Java website](https://www.java.com/en/download/).
-
-2. **Select your Operating System for instructions on setting up Bazel:**
-
-   - [For Windows/Ubuntu/Fedora](https://github.com/oppia/oppia-android/wiki/Bazel-Setup-Instructions-for-Windows)
-   - [For Mac including M1/M2](https://github.com/oppia/oppia-android/wiki/Bazel-Setup-Instructions-for-Mac)
-   - [For Linux](https://github.com/oppia/oppia-android/wiki/Bazel-Setup-Instructions-for-Linux)
+Follow the instructions on the [installation page](https://github.com/oppia/oppia-android/wiki/Installing-Oppia-Android#install-bazel) to set up Bazel.
 
 ### Building the app
path: wiki/Oppia-Bazel-Glossary.md
user: login: adhiamboperes
body: Moved the CLI instructions here from the installation page.
created_at: 2025-03-14T11:00:28Z
author_association: CONTRIBUTOR
diff_hunk: @@ -3,60 +3,53 @@
 - [Overview](#overview)
 - [Installation](#installation)
   - [Building the app](#building-the-app)
-  - [Building + installing the app](#building--installing-the-app)
   - [Running specific module (app) Robolectric tests](#running-specific-module-app-robolectric-tests)
   - [Running all Robolectric tests (slow)](#running-all-robolectric-tests-slow)
-- [Known Issues and Troubleshooting](#known-issues-and-troubleshooting)
 - [Concepts and Terminology](#concepts-and-terminology)
+- [Syncing the Project](#syncing-the-project)
 
 ## Overview
 Bazel is an open-source build and test tool similar to Make, Maven, and Gradle. It uses a human-readable, high-level build language.
 
 **WARNING: We recommend to not use the Android Studio Bazel plugin since it currently has compatibility issues with the project.**
 
-### Installation
+## Installation
 
-1. Download and Install Java 11 using the links from the [Java website](https://www.java.com/en/download/).
-
-2. **Select your Operating System for instructions on setting up Bazel:**
-
-   - [For Windows/Ubuntu/Fedora](https://github.com/oppia/oppia-android/wiki/Bazel-Setup-Instructions-for-Windows)
-   - [For Mac including M1/M2](https://github.com/oppia/oppia-android/wiki/Bazel-Setup-Instructions-for-Mac)
-   - [For Linux](https://github.com/oppia/oppia-android/wiki/Bazel-Setup-Instructions-for-Linux)
+Follow the instructions on the [installation page](https://github.com/oppia/oppia-android/wiki/Installing-Oppia-Android#install-bazel) to set up Bazel.
 
 ### Building the app
 
 After the installation completes you can build the app using Bazel.
 
 **Move your command line head to the `~/opensource/oppia-android`**, then run the below bazel command:
 
+On Sdk 29 and below, run:
path: wiki/Oppia-Bazel-Glossary.md
user: login: adhiamboperes
body: Fixed
created_at: 2025-03-14T11:01:03Z
author_association: CONTRIBUTOR
diff_hunk: @@ -133,3 +126,59 @@ oppia_android_test(
     ],
 )
 ```
+
+## Syncing the Project
+The IntelliJ Bazel Plugin's Sync process has a purpose to query Bazel for information and build up IntelliJ's project structure to fit Bazel's model.
+
+It runs automatically during a project import, and manually by either clicking on the sync icon in the menu bar or, partially syncing packages and individual files in contextual menus.
+
+Running a sync generates a `.aswb` directory in the project root. 
+
+### Structure of the .aswb
+The `.aswb` is known as the **project directory**. It contains metadata about the project that bridges Bazel and IntelliJ project models.
+```
+.aswb/
+├── .bazelproject
+├── .blaze
+│   ├── aar_libraries
+│   ├── modules
+│   ├── remoteOutputCache 
+│   └── renderjars
+└── .idea
+```
+
+The `.bazelproject` is the project view file which contains project-wide settings, like targets to sync, Bazel flags, and enabled languages. It is used to import a subset of Bazel packages into the IDE. The project view determines which rules are imported and how. Read more information [here](https://ij.bazel.build/docs/project-views.html).
+
+The `.blaze` is the Bazel data subdirectory, containing mostly IntelliJ module definitions. 
+  - `modules` directory contains IntelliJ module definition files.
+  - `remoteOutputCache` is a general-purpose local cache for output artifacts generated remotely. During a project sync, updated outputs of interest will be copied locally.
+  - `aar_libraries` is the location of the plugin's JAR cache. This helps provide a more robust code navigation experience, but with the possibility of missing changes made by Bazel outside of the IDE view.
+
+The `.idea` directory contains project-specific settings files managed by IntelliJ. IntelliJ reads XML files in this directory to set up the Project Structure: project, modules, libraries, SDKs, facets.
+
+### Syncing (and Partial Syncing) the Bazel Plugin in Android Studio
+When you make certain changes to your project files, you need to sync your project with Bazel to pick up those changes. For example:
+* Changing a BUILD file, like adding a new target, or adding dependencies and sources to a target.
+* Changing generated output files required to resolve source code, like annotation processor outputs such as AutoValue-generated classes.
+
+You can sync with Bazel in two ways:
+* From your IDE’s menu, click **Bazel > Sync > Sync Project with BUILD files.**
+* From the toolbar, click the **Sync Project with BUILD files** button.
+
+**Expand Sync to Working Set**
+Your working set is any files your VCS says are dirty, roughly corresponding to something like git status. By default the plugin tries to expand the sync to cover any target in your working set. This ensures these files are refreshed without having to go to the trouble of adding a temporary target to your project view.
+- This sometimes causes problems, and you may see a warning in your Bazel sync tool window to disable it.
+
+**Non-Incrementally Sync Project with BUILD Files**
+This option recomputes certain things that are otherwise cached. 
+- You should never have to use this option, but exists for debugging/fallback purposes.
+
+**Sync Working Set**
+Your working set is any files your VCS says are dirty, roughly corresponding to something like git status. This option tries to sync only your working set, cutting down on sync time, which is useful if you want to quickly bring in new dependencies in some files you are working on.
+
+**Partially Sync File with Bazel**
+Syncs only the targets corresponding to the file from which this action is invoked. Can cut down on the time to sync the project if you’re only interested in resolving a single file.
+- This is invoked from the current active file.
path: wiki/Oppia-Bazel-Glossary.md
user: login: adhiamboperes
body: Added these points.
created_at: 2025-03-14T11:09:56Z
author_association: CONTRIBUTOR
diff_hunk: @@ -133,3 +126,59 @@ oppia_android_test(
     ],
 )
 ```
+
+## Syncing the Project
+The IntelliJ Bazel Plugin's Sync process has a purpose to query Bazel for information and build up IntelliJ's project structure to fit Bazel's model.
+
+It runs automatically during a project import, and manually by either clicking on the sync icon in the menu bar or, partially syncing packages and individual files in contextual menus.
+
+Running a sync generates a `.aswb` directory in the project root. 
+
+### Structure of the .aswb
+The `.aswb` is known as the **project directory**. It contains metadata about the project that bridges Bazel and IntelliJ project models.
+```
+.aswb/
+├── .bazelproject
+├── .blaze
+│   ├── aar_libraries
+│   ├── modules
+│   ├── remoteOutputCache 
+│   └── renderjars
+└── .idea
+```
+
+The `.bazelproject` is the project view file which contains project-wide settings, like targets to sync, Bazel flags, and enabled languages. It is used to import a subset of Bazel packages into the IDE. The project view determines which rules are imported and how. Read more information [here](https://ij.bazel.build/docs/project-views.html).
+
+The `.blaze` is the Bazel data subdirectory, containing mostly IntelliJ module definitions. 
+  - `modules` directory contains IntelliJ module definition files.
+  - `remoteOutputCache` is a general-purpose local cache for output artifacts generated remotely. During a project sync, updated outputs of interest will be copied locally.
+  - `aar_libraries` is the location of the plugin's JAR cache. This helps provide a more robust code navigation experience, but with the possibility of missing changes made by Bazel outside of the IDE view.
+
+The `.idea` directory contains project-specific settings files managed by IntelliJ. IntelliJ reads XML files in this directory to set up the Project Structure: project, modules, libraries, SDKs, facets.
+
+### Syncing (and Partial Syncing) the Bazel Plugin in Android Studio
+When you make certain changes to your project files, you need to sync your project with Bazel to pick up those changes. For example:
+* Changing a BUILD file, like adding a new target, or adding dependencies and sources to a target.
+* Changing generated output files required to resolve source code, like annotation processor outputs such as AutoValue-generated classes.
+
+You can sync with Bazel in two ways:
+* From your IDE’s menu, click **Bazel > Sync > Sync Project with BUILD files.**
+* From the toolbar, click the **Sync Project with BUILD files** button.
+
+**Expand Sync to Working Set**
+Your working set is any files your VCS says are dirty, roughly corresponding to something like git status. By default the plugin tries to expand the sync to cover any target in your working set. This ensures these files are refreshed without having to go to the trouble of adding a temporary target to your project view.
+- This sometimes causes problems, and you may see a warning in your Bazel sync tool window to disable it.
+
+**Non-Incrementally Sync Project with BUILD Files**
+This option recomputes certain things that are otherwise cached. 
+- You should never have to use this option, but exists for debugging/fallback purposes.
+
+**Sync Working Set**
+Your working set is any files your VCS says are dirty, roughly corresponding to something like git status. This option tries to sync only your working set, cutting down on sync time, which is useful if you want to quickly bring in new dependencies in some files you are working on.
+
+**Partially Sync File with Bazel**
+Syncs only the targets corresponding to the file from which this action is invoked. Can cut down on the time to sync the project if you’re only interested in resolving a single file.
+- This is invoked from the current active file.
+
+**Automatic Sync**
path: wiki/Oppia-Bazel-Glossary.md
user: login: adhiamboperes
body: It is most likely not performant. I have added the recommendation.
created_at: 2025-03-14T11:11:00Z
author_association: CONTRIBUTOR
diff_hunk: @@ -5,32 +5,313 @@ This wiki page explains how to install Oppia Android on your local machine. If y
 ## Table of Contents
 
 - [Prepare developer environment](#prepare-developer-environment)
+- [install Bazel](#install-bazel)
+  - [Bazel setup for Mac](#bazel-set-up-for-mac)
+  - [Bazel setup for Linux](#bazel-set-up-for-linux)
+  - [Bazel setup for Windows](#bazel-set-up-for-windows)
 - [Install oppia-android](#install-oppia-android)
 - [Run the app from Android Studio](#run-the-app-from-android-studio)
+- [Run the app from the command line](#run-the-app-from-the-command-line)
 - [Set up and Run tests](#set-up-and-run-tests)
   - [Step-by-Step guidance for setting up and running app modules robolectric test](#step-by-step-guidance-for-setting-up-and-running-app-modules-robolectric-test)
   - [For tests that are in non-app modules, such as **domain** or **utility**:](#for-tests-that-are-in-non-app-modules-such-as-domain-or-utility)
-
+- [Next Steps](#next-steps)
+- [Troubleshooting Installation](#troubleshooting-installation)
 
 ## Prepare developer environment
 
-1. Download/Install [Android Studio Bumblebee | Patch 3](https://developer.android.com/studio/archive).
-
-   **Note**: We recommend installing **Android Studio Bumblebee | 2021.1.1 Patch 3** because newer versions of Android Studio[ do not support running tests where shared source sets are used](https://issuetracker.google.com/issues/232007221#comment18), a configuration we use at Oppia.
-
-   **Direct download Url**: [Windows](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-windows.exe) | [Linux](https://redirector.gvt1.com/edgedl/android/studio/ide-zips/2021.1.1.23/android-studio-2021.1.1.23-linux.tar.gz) | [Intel Mac](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-mac.dmg) | [Apple Silicon Mac](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-mac_arm.dmg)
-
-   You can have multiple versions of Android Studio installed on your machine at the same time.
+1. Download/Install the latest version of Android Studio from [this location](https://developer.android.com/studio).
+   **Note**: We strongly recommend **Giraffe** because it has been tested and produced the best experience across different OSes.
 
 2. Configure your Android Studio
-   - In Android Studio, open Tools > SDK Manager.
-     - In the "SDK Platforms" tab (which is the default), select `API Level 28` and also `API Level 30` (for Bazel support).
+   - In Android Studio, open **Tools** > **SDK Manager**.
+     - In the "SDK Platforms" tab (which is the default), select `API Level 29` and also `API Level 30`.
      - Also, navigate to the "SDK Tools" tab, click the "Show Package Details" checkbox at the bottom right, then click on "Android SDK Build-Tools 34-rc1" and select 32.0.0 (this is needed for Bazel support).
 
    - Then, click "Apply" to download and install these two SDKs/Tools.
 
-   - Must have **JDK 11** selected:
-     - In Android Studio, open Settings > Build, Execution, Deployment > Build Tools > Gradle and edit the Gradle JDK field.
+3. Prepare a test device
+   You require a physical Android device or an Android emulator to run the Oppia app. 
+   - Physical devices are useful for a real-user experience feel, and testing with [accessibility tools](https://github.com/oppia/oppia-android/wiki/Accessibility-A11y-Guide#setting-up-accessibility-scanner-and-talkback).
+   
+     **Set up a physical device for development**
+      - On the device, open the **Settings** app, select **Developer options**, and then **enable USB debugging** (if applicable).
+        - If you don't see **Developer options**, you might need to enable developer mode first. Follow [these instructions](https://developer.android.com/studio/debug/dev-options#enable) to do so.
+        - Connect to your device using USB.
+        - Verify that your device is connected by running the `adb devices` command from your terminal.
+   
+      - Emulators provide the flexibility of testing the application on a variety of devices and Android API levels without needing to have each physical device.
+   
+     **Set up an Emulator**
+      - For the best experience, you should use the emulator in Android Studio on a computer with at least the following specs:
+        - 16 GB RAM
+        - 64-bit Windows 10 or higher, MacOS 12 or higher, Linux, or ChromeOS operating system
+        - 16 GB disk space
+     
+      - If you don't have these specs, the emulator might still run but not smoothly. In this case, consider testing on a physical device.
+
+       - In Android Studio, in the right hand toolbar, locate `device Manager`.
+       - Click the **+**, and then click **Create Virtual Device**.
+       - Create a phone and a tablet AVD.
+       - After creating your devices, you will be able to see a list of all the devices on the device manager panel.
+       - For more information on the different configurations available for AVDs, please visit the [official documentation page.](https://developer.android.com/studio/run/managing-avds)
+
+## Install Bazel
+### Instructions
+
+**The steps to setting up Bazel are:**
+1. Install Bazel
+2. Set Bazel and ANDROID_HOME paths permanently in your terminal
+3. Verify that the build is working
+
+The expected output of `bazel --version` once Bazel set up is successful is:
+
+```
+bazel 6.5.0
+```
+
+### Bazel Set up for Mac
+It is recommended to use the binary installer steps outline below. For other ways to install Bazel on Mac, refer to the [official page](https://bazel.build/install/os-x).
+
+**Step 1: Install Xcode command line tools**
+
+In macOS 14 or earlier, it is sufficient to install the Xcode command line tools package by using xcode-select:
+
+```
+xcode-select --install
+```
+
+Otherwise, for macOS 15 and later, you must have Xcode 6.1 or later installed on your system.
+
+Download Xcode from the [App Store](https://apps.apple.com/us/app/xcode/id497799835) or the [Apple Developer site](https://developer.apple.com/download/more/?=xcode).
+
+Once Xcode is installed, accept the license agreement for all users with the following command:
+
+```
+sudo xcodebuild -license accept
+```
+
+**Step 2: Download the Bazel installer**
+
+Click [here](https://github.com/bazelbuild/bazel/releases/download/6.5.0/bazel-6.5.0-installer-darwin-x86_64.sh) to download the Bazel 6.5.0 binary installer.
+
+**Step 3: Run the installer**
+
+Run the Bazel installer as follows:
+
+```shell
+chmod +x "bazel-6.5.0-installer-darwin-x86_64.sh"
+./bazel-6.5.0-installer-darwin-x86_64.sh --user
+```
+
+**Step 4: Set up your environment**
+
+You must set the path for `Bazel` and `ANDROID_HOME` before running bazel build for oppia-android, otherwise you will get an error.
+
+If you ran the Bazel installer with the `--user` flag as above, the Bazel executable is installed in your $HOME/bin directory. It’s a good idea to add this directory to your default paths, as follows:
+
+```shell
+export PATH="$PATH:$HOME/bin"
+```
+
+To set the `ANDROID_HOME` path permanently in your terminal run these commands:
+
+```
+sudo nano /etc/paths
+```
+- Enter your password, when prompted.
+- Go to the bottom of the file, and enter this path: `$HOME/Library/Android/sdk`
+- Hit control-x to quit.
+- Enter “Y” to save the modified buffer.
+- That’s it! To test it, in a new terminal window, type: `echo $PATH`
+
+**Step 5: Verify that the build is working**
+
+Run the following command in your terminal:
+
+```
+bazel --version
+```
+
+### Bazel Set up for Linux
+This section covers Bazel installation on Ubuntu. 
+
+Recommendations:
+- use Ubuntu 18.04 (LTS), 20.04 (LTS), or 22.04 (LTS).
+- use ``apt`` installation instructions.
+
+- **Note**: if you encounter any errors related to `cURL`, please set up cURL on your machine using `sudo apt install curl`.
+
+**Step 1: Add Bazel distribution URI as a package source**
+
+This is a one-time setup step.
+
+```
+sudo apt install apt-transport-https curl gnupg -y
+curl -fsSL https://bazel.build/bazel-release.pub.gpg | gpg --dearmor >bazel-archive-keyring.gpg
+sudo mv bazel-archive-keyring.gpg /usr/share/keyrings
+echo "deb [arch=amd64 signed-by=/usr/share/keyrings/bazel-archive-keyring.gpg] https://storage.googleapis.com/bazel-apt stable jdk1.8" | sudo tee /etc/apt/sources.list.d/bazel.list
+```
+
+**Step 2: Install and update Bazel**
+
+Run:
+```shell
+sudo apt update && sudo apt install bazel-6.5.0
+```
+
+**Step 3: Set up your environment**
+
+Ensure that your `ANDROID_HOME` environment variable is set to the location of your Android SDK. To do this, find the path to the installed SDK using Android Studio’s SDK Manager (install SDK 28). Assuming the SDK is installed to default locations, you can use the following commands to set the `ANDROID_HOME` variable:<br>
+```
+export ANDROID_HOME=$HOME/Android/Sdk/
+```
+
+**Step 4: Verify that the build is working**
+
+Run the following command in your terminal:
+
+```
+bazel --version
+```
+
+### Bazel Set up for Windows
+This page outlines one way to allow Bazel to be used in CLI form on Windows. Please note that **this support is currently experimental**. You may run into some problems--we suggest that you post a discussion at [github-discussions](https://github.com/oppia/oppia-android/discussions).
+
+Unlike Unix-based systems where Bazel runs natively without issue, the current solution on Windows is to install an Ubuntu-based subsystem. Windows currently only supports a terminal experience in this subsystem (though there is a prerelease version of the software with GUI support) which means Android Studio will not be supported. You will need to continue using the Windows version of Android Studio and only use the Linux subsystem for building & running Robolectric or JUnit-based tests.
+
+Due to the issues mentioned above, we recommend dual-booting your PC with Linux. However, if you choose to use windows, please follow the instructions below:
+
+**Main prerequisites**:
+- Windows 10: These instructions are geared towards users of Windows 10 (older versions will not be compatible). If you're in using an older version of Windows, please follow up with a comment on [this issue](https://github.com/oppia/oppia-android/issues/3371).
path: wiki/Installing-Oppia-Android.md
user: login: adhiamboperes
body: Updated to 10+ for now
created_at: 2025-03-14T11:16:39Z
author_association: CONTRIBUTOR
diff_hunk: @@ -0,0 +1,221 @@
+## Table of Contents
+
+- [Overview](#overview)
+- [Installation](#installation)
+  - [Building the app](#building-the-app)
+  - [Running specific module (app) Robolectric tests](#running-specific-module--app--robolectric-tests)
+  - [Running all Robolectric tests (slow)](#running-all-robolectric-tests--slow-)
+- [Concepts and Terminology](#concepts-and-terminology)
+- [Syncing the Project](#Syncing-the-project)
+
+## Overview
+Bazel is an open-source build and test tool similar to Make, Maven, and Gradle. It uses a human-readable, high-level build language.
+
+## Installation
+
+Follow the instructions on the [installation page](https://github.com/oppia/oppia-android/wiki/Installing-Oppia-Android#install-bazel) to set up Bazel.
+
+### Building the app
+
+The [installation page](https://github.com/oppia/oppia-android/wiki/Installing-Oppia-Android#install-bazel) provides information on running the project in Android Studio.
+
+You can also run the app from the command line using the commands detailed below.
+
+Using the command line is helpful in instances when you need to run some targets outside of Android Studio.
+
+Run the following commands in your terminal. All Bazel commands must be run from the root of the `oppia-android` directory otherwise they will fail.
+
+Note that on the first run, these commands may take 10-20 minutes to complete depending on the performance of your machine. Subsequent runs will be much faster.
+
+**On SDK 29 and below, run**:
+   ```
+   bazel mobile-install //:oppia_dev_binary
+   ```
+This will build, install and launch the app on your device.
+
+**On SDK 30 and newer, run**:
+   ```
+   bazel build //:oppia_dev
+   ```
+followed by:
+   ```
+   adb install bazel-bin/oppia_dev_binary.apk  
+   ```
+* Starting from Sdk 30, incremental builds, like those executed using `bazel mobile-install`, are no longer permitted, necessitating the use of two separate commands.
+
+If everything is working, you should see output like the following:
+
+```
+Target //:oppia_dev up-to-date:
+  bazel-bin/oppia_dev.aab
+INFO: Elapsed time: ...
+INFO: 1 process...
+INFO: Build completed successfully, ...
+```
+
+Note also that the ``oppia_dev.aab`` under the ``bazel-bin`` directory of your local copy of Oppia Android should be a fully functioning development version of the app that can be installed using bundle-tool. However, it's recommended to deploy Oppia to an emulator or connected device using the `mobile-install` command.
+
+### Running specific module (app) Robolectric tests
+
+```
+bazel test //app/...
+```
+
+### Running all Robolectric tests (slow)
+
+```
+bazel test //...
+```
+
+## Concepts and Terminology
+**[Workspace](https://github.com/oppia/oppia-android/blob/develop/WORKSPACE)**
+
+A workspace is a directory where we add targeted SDK version, all the required dependencies and there required Rules. The directory containing the WORKSPACE file is the root of the main repository, which in our case is the `oppia-android` root directory is the main directory.
path: wiki/Bazel-User-Guide.md
user: login: manas-yu
body: ```suggestion
A workspace is a directory where we specify the targeted SDK version, required dependencies, and corresponding Rules. The directory containing the WORKSPACE file is the root of the main repository, which in our case, is the `oppia-android` root directory.
```
created_at: 2025-03-14T20:29:00Z
author_association: CONTRIBUTOR
diff_hunk: @@ -63,85 +350,145 @@ Please follow these steps to set up Oppia Android on your local machine.
        5. Download the [google_checks.xml](https://github.com/checkstyle/checkstyle/blob/14005e371803bd52dff429904b354dc3e72638c0/src/main/resources/google_checks.xml) file. To do this, you can simply right-click on the download button at the top-right of the file.
        6. Copy this file to the directory where Git is installed (usually C:/Program Files/Git/).
 
-3. In Android Studio, select `File > Open`, navigate to `opensource/oppia-android/`, and click `OK` to load the project.
+## Opening the project in Android Studio
+
+1. Launch Android Studio, and on the welcome screen, select **Plugins** to install the Bazel for Android Studio plugin and restart Android Studio.
+
+2. On next open, click the options button next to the new project/open project to find the "Import Bazel Project" option.
+
+   <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/efcc4e6e-b6ba-44fc-9c96-aa381de83911" />
+
+3. A setup wizard will open. For Workspace, click (**...**) to open file manager and select `/opensource/oppia-android` as the location since this is where we have our project's `WORKSPACE` file.
+
+   ![Image](https://github.com/user-attachments/assets/9baf6f71-560b-49fe-84a7-c7b846a64287)
+
+4. On **OK**, you will be asked to **Trust project**. Accept because we trust the project.
+
+   <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/bfc91f6d-d809-418d-ab20-89d899f12f72" />
+
+5. On **next**, to Select Project View, **select Create from scratch**.
+
+   <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/cdc110d6-2926-4f96-b7d8-117e2c716f76" />
 
-4. Select the Compile JDK version
-   - Go to Android Studio > Settings > Build, Execution, Deployment > Build Tools > Gradle
-   - Under "**Gradle JDK**", select Android Studio Default JDK 11.
-   - Then, click "Apply" and "OK" to complete your setup.
-5. Click the elephant icon in the toolbar ("Sync Gradle") to ensure that all the correct dependencies are downloaded. (In general, you'll want to do this step any time you update your dependencies.)
+6. A file similar to the one below will be generated:
 
-## Run the app from Android Studio
+   <img width="760" alt="Image" src="https://github.com/user-attachments/assets/5a26210f-865d-4048-b5a5-73379984bfb5" />
 
-1. Go to Tools > AVD Manager, click "Create Virtual Device...". Then:
+7. In the above file, modify it so that it looks like below (copy and paste):
+   
+   ```
+   directories:
+      # Add the directories you want added as source here
+      # By default, we've added your entire workspace ('.')
+      .
+      
+   # Automatically includes all relevant targets under the 'directories' above
+   derive_targets_from_directories: false
+   
+   targets:
+   # If source code isn't resolving, add additional targets that compile it here
+      //:oppia_dev_binary
+      //app //app/src/main/... 
path: wiki/Installing-Oppia-Android.md
user: login: manas-yu
body: ```suggestion
      //app 
      //app/src/main/... 
```
created_at: 2025-03-14T20:29:10Z
author_association: CONTRIBUTOR
diff_hunk: @@ -63,85 +350,145 @@ Please follow these steps to set up Oppia Android on your local machine.
        5. Download the [google_checks.xml](https://github.com/checkstyle/checkstyle/blob/14005e371803bd52dff429904b354dc3e72638c0/src/main/resources/google_checks.xml) file. To do this, you can simply right-click on the download button at the top-right of the file.
        6. Copy this file to the directory where Git is installed (usually C:/Program Files/Git/).
 
-3. In Android Studio, select `File > Open`, navigate to `opensource/oppia-android/`, and click `OK` to load the project.
+## Opening the project in Android Studio
+
+1. Launch Android Studio, and on the welcome screen, select **Plugins** to install the Bazel for Android Studio plugin and restart Android Studio.
+
+2. On next open, click the options button next to the new project/open project to find the "Import Bazel Project" option.
+
+   <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/efcc4e6e-b6ba-44fc-9c96-aa381de83911" />
+
+3. A setup wizard will open. For Workspace, click (**...**) to open file manager and select `/opensource/oppia-android` as the location since this is where we have our project's `WORKSPACE` file.
+
+   ![Image](https://github.com/user-attachments/assets/9baf6f71-560b-49fe-84a7-c7b846a64287)
+
+4. On **OK**, you will be asked to **Trust project**. Accept because we trust the project.
+
+   <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/bfc91f6d-d809-418d-ab20-89d899f12f72" />
+
+5. On **next**, to Select Project View, **select Create from scratch**.
+
+   <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/cdc110d6-2926-4f96-b7d8-117e2c716f76" />
 
-4. Select the Compile JDK version
-   - Go to Android Studio > Settings > Build, Execution, Deployment > Build Tools > Gradle
-   - Under "**Gradle JDK**", select Android Studio Default JDK 11.
-   - Then, click "Apply" and "OK" to complete your setup.
-5. Click the elephant icon in the toolbar ("Sync Gradle") to ensure that all the correct dependencies are downloaded. (In general, you'll want to do this step any time you update your dependencies.)
+6. A file similar to the one below will be generated:
 
-## Run the app from Android Studio
+   <img width="760" alt="Image" src="https://github.com/user-attachments/assets/5a26210f-865d-4048-b5a5-73379984bfb5" />
 
-1. Go to Tools > AVD Manager, click "Create Virtual Device...". Then:
+7. In the above file, modify it so that it looks like below (copy and paste):
+   
+   ```
+   directories:
+      # Add the directories you want added as source here
+      # By default, we've added your entire workspace ('.')
+      .
+      
+   # Automatically includes all relevant targets under the 'directories' above
+   derive_targets_from_directories: false
+   
+   targets:
+   # If source code isn't resolving, add additional targets that compile it here
+      //:oppia_dev_binary
+      //app //app/src/main/... 
+      //domain/src/main/... 
+      //testing/src/main/... 
+      //utility/src/main/... 
+      //data/src/main/... 
+      //model/...
+      
+   additional_languages:
+      # Uncomment any additional languages you want supported
+      # c
+      # dart
+      # kotlin
+      java
+      kotlin
 
-   - Select a preferred device definition. In general, any device is fine, but you can use Pixel 3a as a default (if you're developing for phones) or Nexus 7 (if you're developing for tablets). After selecting a device, click "Next" at the bottom right to continue.
-   - Select a system image (in general, API Level 28, unless you're an M1 Mac user, in which case use API Level 29). Then click "Next".
-   - Click "Finish" to complete setup.
+   # Please uncomment an android-SDK platform. Available SDKs are:
+      # android_sdk_platform: android-28
+      # android_sdk_platform: android-29
+      android_sdk_platform: android-30
+      # android_sdk_platform: android-31
+      # android_sdk_platform: android-32
+      # android_sdk_platform: android-33
+      android_sdk_platform: android-34
+   
+   shard_sync: true
+   
+   java_language_level: 11
+   ```
+   **Note**: Only enable Android-SDK platforms that you have installed per the [Prepare developer environment](#prepare-developer-environment) section above. Android-SDK platforms are useful for creating emulators to test your app with.
 
-2. To run the app, select the emulator device you want from the dropdown menu to the left of the "Run" button in the toolbar.
+8. Click **Create**, and allow the project to synchronize.
 
-3. Finally, click the "Run" button.
+9. Once sync has finished, you can now build and install the app on either a virtual or physical device. Bazel supports deploying to only one device at a time, so you can connect one device, or launch one emulator at a time.
+
+   You can run the project by using the Bazel plugin to set up run configurations for the target that you wish to build. This performs the same action as the run commands listed in the [Bazel user guide](https://github.com/oppia/oppia-android/wiki/Bazel-User-Guide), but using the GUI to run the app might be more intuitive for some developers.
+
+   ![Screenshot 2025-02-26 at 22 16 32](https://github.com/user-attachments/assets/f3be5288-dc96-4079-bcb2-b514de81f899)
+
+   Edit configurations allows us to specify the run command:
+
+   ![Image](https://github.com/user-attachments/assets/7270b6b3-11ac-4b49-a39a-734e0437bb9e)
+
+     - Target **Name**, is helpful for identifying the target from the list on the left.
+     - **Target expression** requires a build target such as `//:oppia_dev_binary`.
+     - **The Bazel command** is `mobile-install`
+     - **Bazel flags** are optional.
+     - Select **Apply** and then **Close** or **Ok**.
 
 ## Set up and run tests
 Testing the app is an integral part of our development process. You will need to test all code changes to ensure that the app works correctly, therefore it is important to ensure that your test configuration works.
 
-We strongly recommend running tests on Robolectric which is faster because it does not require a physical device or emulator setup.
+Our Bazel setup currently supports running tests on Robolectric which is fast because it does not require a physical device or emulator setup.
 
-### Configure Robolectric Tests
+We can run tests either through the UI supported by the Bazel Plugin, or via running a `bazel test` command on the terminal, i.e.:
 
-#### Step-by-Step guidance for setting up and running app modules robolectric test:
+> Tip 1: In order to get the correct path always, open the test file, then on the AS sidebar, right click on the file, and select `copy path/reference`. Then select `copy path from repository root`. Paste the copied path to terminal and remove the `.kt` extension. This can also be achieved by right clicking on the file tab if the test file is open and copy the copy path/reference.
 
-1. Go to **Edit Configuration** in Android Studio (Bumblebee | 2021.1.1 Patch 3)
-   ![](https://user-images.githubusercontent.com/9396084/79109714-83525980-7d96-11ea-99d7-f83ea81a8a50.png)
+   ```
+   bazel test full-path-of-test-file
+   ```
 
-2. Click on Add(+) -> **JUnit**
-   ![](https://github.com/oppia/oppia-android/assets/76530270/87caf3fc-37d9-472d-92fd-b8ec49fb6b49)
+e.g.
+   
+   ```
+   bazel test domain/src/test/java/org/oppia/android/domain/onboarding/AppStartupStateControllerTest
+   ```
 
-3. Enter following information:
-   - a) Name of test. Example: In my case "SplashActivityTest"
-   - b) Make sure select "java 11" and oppia-android.app
-   - c) Class path of Test class. Example: In my case "org.oppia.android.app.splash.
-   SplashActivityTest"
-   - d) Press `OK` to select the test.
-   ![](https://github.com/oppia/oppia-android/assets/76530270/5901624a-df76-4b27-8f31-6077a68fcb89)
+> Tip 2: You can pass a target argument to the `bazel test` command instead. Copy the relative path to the test file and query its target using `bazel query relative-path-of-test-file` e.g. `bazel query domain/src/test/java/org/oppia/android/domain/onboarding/AppStartupStateControllerTest.kt`. This will give you a Bazel target (i.e. starts with '//') --just copy that and remove the `.kt` at the end and you can pass it to `bazel test`, e.g.
 
-4. Click on "Run" button to run robolectric test. (In my case "SplashActivityTest")
-   ![](https://github.com/oppia/oppia-android/assets/76530270/75a6b998-90c5-4f0a-8886-78f96970be90)
+```
+bazel test //domain/src/test/java/org/oppia/android/domain/onboarding:AppStartupStateControllerTest
+```
 
-#### For tests that are in non-app modules, such as **domain** or **utility**::
+### Configure Robolectric Tests
+
+#### Step-by-Step guidance for setting up and running app module robolectric tests:
+
+1. In Android Studio, open the test file that you wish to run. If sync completed successfully when the project was opened, there will be a green run arrow next to the class name, as well as next to each individual test name. Clicking on the arrow will run either the full class or a single test as selected.
 
-1. In Android Studio, open the desired test file, e.g., `AnalyticsControllerTest`.
-2. In the test file, to the left of the class name, click on the orange and green arrow, and select **Run 'AnalyticsControllerTest'**.
-   - You will notice that the emulator is greyed out, but the run window will open to show the running tests:
-   ![](https://user-images.githubusercontent.com/59600948/272657015-158117e5-47d2-40fc-a38b-5dee6c347556.png)
+2. Because we have set up the Bazel plugin, we can also run a test class using the run arrow at the top of the project window:
 
-### Configure Emulator Tests
+   ![Screenshot 2025-02-26 at 22 16 32](https://github.com/user-attachments/assets/f3be5288-dc96-4079-bcb2-b514de81f899)
 
-**Espresso is slower for running tests, so we recommend using Robolectric.**
+   Edit configurations allows us to specify the run command:
+   ![Screenshot 2025-02-26 at 22 19 34](https://github.com/user-attachments/assets/462d07d2-4407-4898-bbc4-544509bd7486)
 
-1. In Android Studio, open the desired test file, e.g., `HomeActivityTest`.
-2. In the Android Studio toolbar, click on the `Available Devices` option. Select an emulator that has between API 28-30.
+   - Test **name**, is helpful for identifying the test target from the list on the left.
+   - **Target expression** requires the fully qualified path to the test file.
+   - **The Bazel command** for running tests is `test`
+   - **Bazel flags** are optional.
+   - Select **Apply** and then **Close** or **Ok**.
 
-   **Note**: If you don't have any available devices in this list, please follow [these instructions](#run-the-app-from-android-studio) to create one.
+#### For tests that are in non-app modules, such as **domain** or **utility**::
 
-3. In the test file, to the left of the class name, click on the orange and green arrow, and select **Run 'HomeActivityTest'**.
-   ![](https://user-images.githubusercontent.com/59600948/272657131-96e5354b-13a9-4709-969a-b9494a65c30f.png)
+1. In Android Studio, open the test file that you wish to run. If sync completed successfully when the project was opened, there will be a green run arrow next to the class name, as well as next to each individual test name. Clicking on the arrow will run either the full class or a single test as selected.
 
-4. An "**Edit Configuration**" dialog will show up, and you should add the following settings under the general tab:
-   - For module, select **oppia-android.app**
-   - For Test, select **Class**
-   - For Instrumentation class, **org.oppia.android.testing.OppiaTestRunner**, will be selected by default.
-   - For target, select the **Use the device/snapshot dropdown** option.
-   - Verify that your setup looks like below:
+2. A second way to run a test class would be to open the `BUILD` file located in the same package as the test file, and clicking on the green arrow next to the test target name.
+  
+   ![Image](https://github.com/user-attachments/assets/c1ee9e23-b0b2-430a-9592-9f87a2fdcbf0)
 
-     ![](https://user-images.githubusercontent.com/59600948/272657260-2e654891-61be-467a-8ebd-c997aa2abda6.png)
-- Finally, Click the "Apply" and "Okay" buttons.
-- You may need to repeat step (3) above to run the test with the new configuration.
-- Subsequent runs of any app module tests will not require editing the configuration.
-- This configuration will run all the tests in that class.
-5. To run only a specific test in a file:
-   - Search or scroll down to the desired test name, to the left of the test name, click on the run icon and select **Run '`test name`''**.
+3. The third way is to run a the test via CLI as mentioned above.
path: wiki/Installing-Oppia-Android.md
user: login: manas-yu
body: ```suggestion
3. The third way is to run the test via CLI as mentioned above.
```
We could also suggest here, the test files that are not yet modularized (i.e., test packages currently missing BUILD files) need to be executed via the CLI.
created_at: 2025-03-14T20:29:20Z
author_association: CONTRIBUTOR
diff_hunk: @@ -63,85 +350,145 @@ Please follow these steps to set up Oppia Android on your local machine.
        5. Download the [google_checks.xml](https://github.com/checkstyle/checkstyle/blob/14005e371803bd52dff429904b354dc3e72638c0/src/main/resources/google_checks.xml) file. To do this, you can simply right-click on the download button at the top-right of the file.
        6. Copy this file to the directory where Git is installed (usually C:/Program Files/Git/).
 
-3. In Android Studio, select `File > Open`, navigate to `opensource/oppia-android/`, and click `OK` to load the project.
+## Opening the project in Android Studio
+
+1. Launch Android Studio, and on the welcome screen, select **Plugins** to install the Bazel for Android Studio plugin and restart Android Studio.
+
+2. On next open, click the options button next to the new project/open project to find the "Import Bazel Project" option.
+
+   <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/efcc4e6e-b6ba-44fc-9c96-aa381de83911" />
+
+3. A setup wizard will open. For Workspace, click (**...**) to open file manager and select `/opensource/oppia-android` as the location since this is where we have our project's `WORKSPACE` file.
+
+   ![Image](https://github.com/user-attachments/assets/9baf6f71-560b-49fe-84a7-c7b846a64287)
+
+4. On **OK**, you will be asked to **Trust project**. Accept because we trust the project.
+
+   <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/bfc91f6d-d809-418d-ab20-89d899f12f72" />
+
+5. On **next**, to Select Project View, **select Create from scratch**.
+
+   <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/cdc110d6-2926-4f96-b7d8-117e2c716f76" />
 
-4. Select the Compile JDK version
-   - Go to Android Studio > Settings > Build, Execution, Deployment > Build Tools > Gradle
-   - Under "**Gradle JDK**", select Android Studio Default JDK 11.
-   - Then, click "Apply" and "OK" to complete your setup.
-5. Click the elephant icon in the toolbar ("Sync Gradle") to ensure that all the correct dependencies are downloaded. (In general, you'll want to do this step any time you update your dependencies.)
+6. A file similar to the one below will be generated:
 
-## Run the app from Android Studio
+   <img width="760" alt="Image" src="https://github.com/user-attachments/assets/5a26210f-865d-4048-b5a5-73379984bfb5" />
 
-1. Go to Tools > AVD Manager, click "Create Virtual Device...". Then:
+7. In the above file, modify it so that it looks like below (copy and paste):
+   
+   ```
+   directories:
+      # Add the directories you want added as source here
+      # By default, we've added your entire workspace ('.')
+      .
+      
+   # Automatically includes all relevant targets under the 'directories' above
+   derive_targets_from_directories: false
+   
+   targets:
+   # If source code isn't resolving, add additional targets that compile it here
+      //:oppia_dev_binary
+      //app //app/src/main/... 
path: wiki/Installing-Oppia-Android.md
user: login: adhiamboperes
body: Fixed
created_at: 2025-03-18T18:15:59Z
author_association: CONTRIBUTOR
diff_hunk: @@ -63,85 +341,183 @@ Please follow these steps to set up Oppia Android on your local machine.
        5. Download the [google_checks.xml](https://github.com/checkstyle/checkstyle/blob/14005e371803bd52dff429904b354dc3e72638c0/src/main/resources/google_checks.xml) file. To do this, you can simply right-click on the download button at the top-right of the file.
        6. Copy this file to the directory where Git is installed (usually C:/Program Files/Git/).
 
-3. In Android Studio, select `File > Open`, navigate to `opensource/oppia-android/`, and click `OK` to load the project.
-
-4. Select the Compile JDK version
-   - Go to Android Studio > Settings > Build, Execution, Deployment > Build Tools > Gradle
-   - Under "**Gradle JDK**", select Android Studio Default JDK 11.
-   - Then, click "Apply" and "OK" to complete your setup.
-5. Click the elephant icon in the toolbar ("Sync Gradle") to ensure that all the correct dependencies are downloaded. (In general, you'll want to do this step any time you update your dependencies.)
-
 ## Run the app from Android Studio
 
-1. Go to Tools > AVD Manager, click "Create Virtual Device...". Then:
+1. Launch Android Studio, and on the welcome screen, select **Plugins** to install the Bazel for Android Studio plugin and restart Android Studio.
 
-   - Select a preferred device definition. In general, any device is fine, but you can use Pixel 3a as a default (if you're developing for phones) or Nexus 7 (if you're developing for tablets). After selecting a device, click "Next" at the bottom right to continue.
-   - Select a system image (in general, API Level 28, unless you're an M1 Mac user, in which case use API Level 29). Then click "Next".
-   - Click "Finish" to complete setup.
+2. On next open, click the options button next to the new project/open project to find the "Import Bazel Project" option.
 
-2. To run the app, select the emulator device you want from the dropdown menu to the left of the "Run" button in the toolbar.
+   <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/efcc4e6e-b6ba-44fc-9c96-aa381de83911" />
 
-3. Finally, click the "Run" button.
+3. A setup wizard will open. For Workspace, click (**...**) to open file manager and select `/opensource/oppia-android` as the location since this is where we have our project's `WORKSPACE` file.
+
+   ![Image](https://github.com/user-attachments/assets/9baf6f71-560b-49fe-84a7-c7b846a64287)
+
+4. On **OK**, you will be asked to **Trust project**. Accept because we trust the project.
+
+   <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/bfc91f6d-d809-418d-ab20-89d899f12f72" />
+
+5. On **next**, to Select Project View, **select Create from scratch**.
+
+   <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/cdc110d6-2926-4f96-b7d8-117e2c716f76" />
+
+6. A file similar to the one below will be generated:
+
+   <img width="760" alt="Image" src="https://github.com/user-attachments/assets/5a26210f-865d-4048-b5a5-73379984bfb5" />
+
+7. In the above file, modify it so that it looks like below(copy and paste):
+   
+   ```
+   directories:
+      # Add the directories you want added as source here
+      # By default, we've added your entire workspace ('.')
+      .
+      
+   # Automatically includes all relevant targets under the 'directories' above
+   derive_targets_from_directories: false
+   
+   targets:
+   # If source code isn't resolving, add additional targets that compile it here
+      //:oppia_dev_binary
+      //app
+      //app/src/main/...
+      //domain/...
+      //model/...
+      //testing/...
+      //utility/...
+      //data/...
+      //scripts/...
+      
+   additional_languages:
+      # Uncomment any additional languages you want supported
+      # c
+      # dart
+      # kotlin
+      java
+      kotlin
+
+   # Please uncomment an android-SDK platform. Available SDKs are:
+      # android_sdk_platform: android-28
+      android_sdk_platform: android-29
+      # android_sdk_platform: android-30
+      # android_sdk_platform: android-31
+      # android_sdk_platform: android-32
+      # android_sdk_platform: android-33
+      android_sdk_platform: android-34
+   
+   shard_sync: true
+   sync_flags:
+      --local_ram_resources=HOST_RAM*.5
+      --discard_analysis_cache
+   
+   java_language_level: 11
+   ```
+   **Note**: Only enable Android-SDK platforms that you have installed per the [Prepare developer environment](#prepare-developer-environment) section above. Android-SDK platforms are useful for creating emulators to test your app with.
+
+8. Click **Create**, and allow the project to synchronize.
+
+9. Once sync has finished, you can now build and install the app on either a virtual or physical device. Bazel supports deploying to only one device at a time, so you can connect one device, or launch one emulator at a time.
+
+   You can run the project by using the Bazel plugin to set up run configurations for the target that you wish to build. This performs the same action as the commands below, but using the GUI to run the app might be more intuitive for some developers.
+
+   ![Screenshot 2025-02-26 at 22 16 32](https://github.com/user-attachments/assets/f3be5288-dc96-4079-bcb2-b514de81f899)
+
+   Edit configurations allows us to specify the run command:
+
+   ![Image](https://github.com/user-attachments/assets/7270b6b3-11ac-4b49-a39a-734e0437bb9e)
+
+     - Target **Name**, is helpful for identifying the target from the list on the left.
+     - **Target expression** requires a build target such as `//:oppia_dev_binary`.
+     - **The Bazel command** is `mobile-install`
+     - **Bazel flags** are optional.
+     - Select **Apply** and then **Close** or **Ok**.
+
+## Run the app from the command line
+
+Using the command line is helpful in instances when you need to run some targets outside of Android Studio.
+
+Run the following commands in your terminal. All Bazel commands must be run from the root of the ‘oppia-android’ directory otherwise they will fail.
+
+Note that on the first run, these commands may take 10-20 minutes to complete depending on the performance of your machine. Subsequent runs will be much faster.
+
+On Sdk 29 and below, run:
+   ```
+   bazel mobile-install //:oppia_dev_binary
+   ```
+This will build, install and launch the app on your device.
+
+On Sdk 30 and newer, run:
+   ```
+   bazel build //:oppia_dev
+   ```
+followed by:
+   ```
+   adb install bazel-bin/oppia_dev_binary.apk  
+   ```
+Starting from Sdk 30, incremental builds, like those executed using `bazel mobile-install`, are no longer permitted, necessitating the use of two separate commands.
+
+If everything is working, you should see output like the following:
+
+```
+Target //:oppia_dev up-to-date:
+  bazel-bin/oppia_dev.aab
+INFO: Elapsed time: ...
+INFO: 1 process...
+INFO: Build completed successfully, ...
+```
+
+Note also that the ``oppia_dev.aab`` under the ``bazel-bin`` directory of your local copy of Oppia Android should be a fully functioning development version of the app that can be installed using bundle-tool. However, it's recommended to deploy Oppia to an emulator or connected device using the `mobile-install` command.
 
 ## Set up and run tests
 Testing the app is an integral part of our development process. You will need to test all code changes to ensure that the app works correctly, therefore it is important to ensure that your test configuration works.
 
-We strongly recommend running tests on Robolectric which is faster because it does not require a physical device or emulator setup.
+Our Bazel setup currently supports running tests on Robolectric which is fast because it does not require a physical device or emulator setup.
 
-### Configure Robolectric Tests
+We can run tests either through the UI supported by the Bazel Plugin, or via running a `bazel test` command on the terminal, i.e.:
 
-#### Step-by-Step guidance for setting up and running app modules robolectric test:
+> Tip 1: In order to get the correct path always, open the test file, then on the AS sidebar, right click on the file, and select `copy path/reference`. Then select `copy path from repository root`. Paste the copied path to terminal and remove the `.kt` extension.
 
-1. Go to **Edit Configuration** in Android Studio (Bumblebee | 2021.1.1 Patch 3)
-   ![](https://user-images.githubusercontent.com/9396084/79109714-83525980-7d96-11ea-99d7-f83ea81a8a50.png)
+   ```
+   bazel test full-path-of-test-file
+   ```
 
-2. Click on Add(+) -> **JUnit**
-   ![](https://github.com/oppia/oppia-android/assets/76530270/87caf3fc-37d9-472d-92fd-b8ec49fb6b49)
+e.g.
+   
+   ```
+   bazel test domain/src/test/java/org/oppia/android/domain/onboarding/AppStartupStateControllerTest
+   ```
 
-3. Enter following information:
-   - a) Name of test. Example: In my case "SplashActivityTest"
-   - b) Make sure select "java 11" and oppia-android.app
-   - c) Class path of Test class. Example: In my case "org.oppia.android.app.splash.
-   SplashActivityTest"
-   - d) Press `OK` to select the test.
-   ![](https://github.com/oppia/oppia-android/assets/76530270/5901624a-df76-4b27-8f31-6077a68fcb89)
+> Tip 2: You can pass a target argument to the `bazel test` command instead. Copy the relative path to the test file and query its target using `bazel query path-of-test-file` e.g. `bazel query domain/src/test/java/org/oppia/android/domain/onboarding/AppStartupStateControllerTest.kt`. This will give you a Bazel target (i.e. starts with '//') --just copy that and remove the `.kt` at the end and you can pass it to `bazel test`, e.g.
 
-4. Click on "Run" button to run robolectric test. (In my case "SplashActivityTest")
-   ![](https://github.com/oppia/oppia-android/assets/76530270/75a6b998-90c5-4f0a-8886-78f96970be90)
+```
+bazel test //domain/src/test/java/org/oppia/android/domain/onboarding:AppStartupStateControllerTest
+```
 
-#### For tests that are in non-app modules, such as **domain** or **utility**::
+### Configure Robolectric Tests
path: wiki/Installing-Oppia-Android.md
user: login: adhiamboperes
body: I kept the basic test instructions here and moved the rest of the instructions and tips to the user guide.
created_at: 2025-03-18T18:38:23Z
author_association: CONTRIBUTOR
diff_hunk: @@ -63,85 +341,183 @@ Please follow these steps to set up Oppia Android on your local machine.
        5. Download the [google_checks.xml](https://github.com/checkstyle/checkstyle/blob/14005e371803bd52dff429904b354dc3e72638c0/src/main/resources/google_checks.xml) file. To do this, you can simply right-click on the download button at the top-right of the file.
        6. Copy this file to the directory where Git is installed (usually C:/Program Files/Git/).
 
-3. In Android Studio, select `File > Open`, navigate to `opensource/oppia-android/`, and click `OK` to load the project.
-
-4. Select the Compile JDK version
-   - Go to Android Studio > Settings > Build, Execution, Deployment > Build Tools > Gradle
-   - Under "**Gradle JDK**", select Android Studio Default JDK 11.
-   - Then, click "Apply" and "OK" to complete your setup.
-5. Click the elephant icon in the toolbar ("Sync Gradle") to ensure that all the correct dependencies are downloaded. (In general, you'll want to do this step any time you update your dependencies.)
-
 ## Run the app from Android Studio
 
-1. Go to Tools > AVD Manager, click "Create Virtual Device...". Then:
+1. Launch Android Studio, and on the welcome screen, select **Plugins** to install the Bazel for Android Studio plugin and restart Android Studio.
 
-   - Select a preferred device definition. In general, any device is fine, but you can use Pixel 3a as a default (if you're developing for phones) or Nexus 7 (if you're developing for tablets). After selecting a device, click "Next" at the bottom right to continue.
-   - Select a system image (in general, API Level 28, unless you're an M1 Mac user, in which case use API Level 29). Then click "Next".
-   - Click "Finish" to complete setup.
+2. On next open, click the options button next to the new project/open project to find the "Import Bazel Project" option.
 
-2. To run the app, select the emulator device you want from the dropdown menu to the left of the "Run" button in the toolbar.
+   <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/efcc4e6e-b6ba-44fc-9c96-aa381de83911" />
 
-3. Finally, click the "Run" button.
+3. A setup wizard will open. For Workspace, click (**...**) to open file manager and select `/opensource/oppia-android` as the location since this is where we have our project's `WORKSPACE` file.
+
+   ![Image](https://github.com/user-attachments/assets/9baf6f71-560b-49fe-84a7-c7b846a64287)
+
+4. On **OK**, you will be asked to **Trust project**. Accept because we trust the project.
+
+   <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/bfc91f6d-d809-418d-ab20-89d899f12f72" />
+
+5. On **next**, to Select Project View, **select Create from scratch**.
+
+   <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/cdc110d6-2926-4f96-b7d8-117e2c716f76" />
+
+6. A file similar to the one below will be generated:
+
+   <img width="760" alt="Image" src="https://github.com/user-attachments/assets/5a26210f-865d-4048-b5a5-73379984bfb5" />
+
+7. In the above file, modify it so that it looks like below(copy and paste):
+   
+   ```
+   directories:
+      # Add the directories you want added as source here
+      # By default, we've added your entire workspace ('.')
+      .
+      
+   # Automatically includes all relevant targets under the 'directories' above
+   derive_targets_from_directories: false
+   
+   targets:
+   # If source code isn't resolving, add additional targets that compile it here
+      //:oppia_dev_binary
+      //app
+      //app/src/main/...
+      //domain/...
+      //model/...
+      //testing/...
+      //utility/...
+      //data/...
+      //scripts/...
+      
+   additional_languages:
+      # Uncomment any additional languages you want supported
+      # c
+      # dart
+      # kotlin
+      java
+      kotlin
+
+   # Please uncomment an android-SDK platform. Available SDKs are:
+      # android_sdk_platform: android-28
+      android_sdk_platform: android-29
+      # android_sdk_platform: android-30
+      # android_sdk_platform: android-31
+      # android_sdk_platform: android-32
+      # android_sdk_platform: android-33
+      android_sdk_platform: android-34
+   
+   shard_sync: true
+   sync_flags:
+      --local_ram_resources=HOST_RAM*.5
+      --discard_analysis_cache
+   
+   java_language_level: 11
+   ```
+   **Note**: Only enable Android-SDK platforms that you have installed per the [Prepare developer environment](#prepare-developer-environment) section above. Android-SDK platforms are useful for creating emulators to test your app with.
+
+8. Click **Create**, and allow the project to synchronize.
+
+9. Once sync has finished, you can now build and install the app on either a virtual or physical device. Bazel supports deploying to only one device at a time, so you can connect one device, or launch one emulator at a time.
+
+   You can run the project by using the Bazel plugin to set up run configurations for the target that you wish to build. This performs the same action as the commands below, but using the GUI to run the app might be more intuitive for some developers.
+
+   ![Screenshot 2025-02-26 at 22 16 32](https://github.com/user-attachments/assets/f3be5288-dc96-4079-bcb2-b514de81f899)
+
+   Edit configurations allows us to specify the run command:
+
+   ![Image](https://github.com/user-attachments/assets/7270b6b3-11ac-4b49-a39a-734e0437bb9e)
+
+     - Target **Name**, is helpful for identifying the target from the list on the left.
+     - **Target expression** requires a build target such as `//:oppia_dev_binary`.
+     - **The Bazel command** is `mobile-install`
+     - **Bazel flags** are optional.
+     - Select **Apply** and then **Close** or **Ok**.
+
+## Run the app from the command line
+
+Using the command line is helpful in instances when you need to run some targets outside of Android Studio.
+
+Run the following commands in your terminal. All Bazel commands must be run from the root of the ‘oppia-android’ directory otherwise they will fail.
+
+Note that on the first run, these commands may take 10-20 minutes to complete depending on the performance of your machine. Subsequent runs will be much faster.
+
+On Sdk 29 and below, run:
+   ```
+   bazel mobile-install //:oppia_dev_binary
+   ```
+This will build, install and launch the app on your device.
+
+On Sdk 30 and newer, run:
+   ```
+   bazel build //:oppia_dev
+   ```
+followed by:
+   ```
+   adb install bazel-bin/oppia_dev_binary.apk  
+   ```
+Starting from Sdk 30, incremental builds, like those executed using `bazel mobile-install`, are no longer permitted, necessitating the use of two separate commands.
+
+If everything is working, you should see output like the following:
+
+```
+Target //:oppia_dev up-to-date:
+  bazel-bin/oppia_dev.aab
+INFO: Elapsed time: ...
+INFO: 1 process...
+INFO: Build completed successfully, ...
+```
+
+Note also that the ``oppia_dev.aab`` under the ``bazel-bin`` directory of your local copy of Oppia Android should be a fully functioning development version of the app that can be installed using bundle-tool. However, it's recommended to deploy Oppia to an emulator or connected device using the `mobile-install` command.
 
 ## Set up and run tests
 Testing the app is an integral part of our development process. You will need to test all code changes to ensure that the app works correctly, therefore it is important to ensure that your test configuration works.
 
-We strongly recommend running tests on Robolectric which is faster because it does not require a physical device or emulator setup.
+Our Bazel setup currently supports running tests on Robolectric which is fast because it does not require a physical device or emulator setup.
 
-### Configure Robolectric Tests
+We can run tests either through the UI supported by the Bazel Plugin, or via running a `bazel test` command on the terminal, i.e.:
 
-#### Step-by-Step guidance for setting up and running app modules robolectric test:
+> Tip 1: In order to get the correct path always, open the test file, then on the AS sidebar, right click on the file, and select `copy path/reference`. Then select `copy path from repository root`. Paste the copied path to terminal and remove the `.kt` extension.
 
-1. Go to **Edit Configuration** in Android Studio (Bumblebee | 2021.1.1 Patch 3)
-   ![](https://user-images.githubusercontent.com/9396084/79109714-83525980-7d96-11ea-99d7-f83ea81a8a50.png)
+   ```
+   bazel test full-path-of-test-file
+   ```
 
-2. Click on Add(+) -> **JUnit**
-   ![](https://github.com/oppia/oppia-android/assets/76530270/87caf3fc-37d9-472d-92fd-b8ec49fb6b49)
+e.g.
+   
+   ```
+   bazel test domain/src/test/java/org/oppia/android/domain/onboarding/AppStartupStateControllerTest
+   ```
 
-3. Enter following information:
-   - a) Name of test. Example: In my case "SplashActivityTest"
-   - b) Make sure select "java 11" and oppia-android.app
-   - c) Class path of Test class. Example: In my case "org.oppia.android.app.splash.
-   SplashActivityTest"
-   - d) Press `OK` to select the test.
-   ![](https://github.com/oppia/oppia-android/assets/76530270/5901624a-df76-4b27-8f31-6077a68fcb89)
+> Tip 2: You can pass a target argument to the `bazel test` command instead. Copy the relative path to the test file and query its target using `bazel query path-of-test-file` e.g. `bazel query domain/src/test/java/org/oppia/android/domain/onboarding/AppStartupStateControllerTest.kt`. This will give you a Bazel target (i.e. starts with '//') --just copy that and remove the `.kt` at the end and you can pass it to `bazel test`, e.g.
 
-4. Click on "Run" button to run robolectric test. (In my case "SplashActivityTest")
-   ![](https://github.com/oppia/oppia-android/assets/76530270/75a6b998-90c5-4f0a-8886-78f96970be90)
+```
+bazel test //domain/src/test/java/org/oppia/android/domain/onboarding:AppStartupStateControllerTest
+```
 
-#### For tests that are in non-app modules, such as **domain** or **utility**::
+### Configure Robolectric Tests
+
+#### Step-by-Step guidance for setting up and running app module robolectric tests:
 
-1. In Android Studio, open the desired test file, e.g., `AnalyticsControllerTest`.
-2. In the test file, to the left of the class name, click on the orange and green arrow, and select **Run 'AnalyticsControllerTest'**.
-   - You will notice that the emulator is greyed out, but the run window will open to show the running tests:
-   ![](https://user-images.githubusercontent.com/59600948/272657015-158117e5-47d2-40fc-a38b-5dee6c347556.png)
+1. In Android Studio, open the test file that you wish to run. If sync completed successfully when the project was opened, there will be a green run arrow next to the class name, as well as next to each individual test name. Clicking on the arrow will run either the full class or a single test as selected.
 
-### Configure Emulator Tests
+2. Because we have set up the Bazel plugin, we can also run a test class using the run arrow at the top of the project window:
 
-**Espresso is slower for running tests, so we recommend using Robolectric.**
+   ![Screenshot 2025-02-26 at 22 16 32](https://github.com/user-attachments/assets/f3be5288-dc96-4079-bcb2-b514de81f899)
 
-1. In Android Studio, open the desired test file, e.g., `HomeActivityTest`.
-2. In the Android Studio toolbar, click on the `Available Devices` option. Select an emulator that has between API 28-30.
+   Edit configurations allows us to specify the run command:
+   ![Screenshot 2025-02-26 at 22 19 34](https://github.com/user-attachments/assets/462d07d2-4407-4898-bbc4-544509bd7486)
 
-   **Note**: If you don't have any available devices in this list, please follow [these instructions](#run-the-app-from-android-studio) to create one.
+   - Test **name**, is helpful for identifying the test target from the list on the left.
+   - **Target expression** requires the fully qualified path to the test file.
+   - **The Bazel command** for running tests is `test`
+   - **Bazel flags** are optional.
+   - Select **Apply** and then **Close** or **Ok**.
 
-3. In the test file, to the left of the class name, click on the orange and green arrow, and select **Run 'HomeActivityTest'**.
-   ![](https://user-images.githubusercontent.com/59600948/272657131-96e5354b-13a9-4709-969a-b9494a65c30f.png)
+#### For tests that are in non-app modules, such as **domain** or **utility**::
path: wiki/Installing-Oppia-Android.md
user: login: adhiamboperes
body: Transferred to teh to the user guide.
created_at: 2025-03-18T18:38:40Z
author_association: CONTRIBUTOR
diff_hunk: @@ -63,85 +350,145 @@ Please follow these steps to set up Oppia Android on your local machine.
        5. Download the [google_checks.xml](https://github.com/checkstyle/checkstyle/blob/14005e371803bd52dff429904b354dc3e72638c0/src/main/resources/google_checks.xml) file. To do this, you can simply right-click on the download button at the top-right of the file.
        6. Copy this file to the directory where Git is installed (usually C:/Program Files/Git/).
 
-3. In Android Studio, select `File > Open`, navigate to `opensource/oppia-android/`, and click `OK` to load the project.
+## Opening the project in Android Studio
+
+1. Launch Android Studio, and on the welcome screen, select **Plugins** to install the Bazel for Android Studio plugin and restart Android Studio.
+
+2. On next open, click the options button next to the new project/open project to find the "Import Bazel Project" option.
+
+   <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/efcc4e6e-b6ba-44fc-9c96-aa381de83911" />
+
+3. A setup wizard will open. For Workspace, click (**...**) to open file manager and select `/opensource/oppia-android` as the location since this is where we have our project's `WORKSPACE` file.
+
+   ![Image](https://github.com/user-attachments/assets/9baf6f71-560b-49fe-84a7-c7b846a64287)
+
+4. On **OK**, you will be asked to **Trust project**. Accept because we trust the project.
+
+   <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/bfc91f6d-d809-418d-ab20-89d899f12f72" />
+
+5. On **next**, to Select Project View, **select Create from scratch**.
+
+   <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/cdc110d6-2926-4f96-b7d8-117e2c716f76" />
 
-4. Select the Compile JDK version
-   - Go to Android Studio > Settings > Build, Execution, Deployment > Build Tools > Gradle
-   - Under "**Gradle JDK**", select Android Studio Default JDK 11.
-   - Then, click "Apply" and "OK" to complete your setup.
-5. Click the elephant icon in the toolbar ("Sync Gradle") to ensure that all the correct dependencies are downloaded. (In general, you'll want to do this step any time you update your dependencies.)
+6. A file similar to the one below will be generated:
 
-## Run the app from Android Studio
+   <img width="760" alt="Image" src="https://github.com/user-attachments/assets/5a26210f-865d-4048-b5a5-73379984bfb5" />
 
-1. Go to Tools > AVD Manager, click "Create Virtual Device...". Then:
+7. In the above file, modify it so that it looks like below (copy and paste):
+   
+   ```
+   directories:
+      # Add the directories you want added as source here
+      # By default, we've added your entire workspace ('.')
+      .
+      
+   # Automatically includes all relevant targets under the 'directories' above
+   derive_targets_from_directories: false
+   
+   targets:
+   # If source code isn't resolving, add additional targets that compile it here
+      //:oppia_dev_binary
+      //app //app/src/main/... 
+      //domain/src/main/... 
+      //testing/src/main/... 
+      //utility/src/main/... 
+      //data/src/main/... 
+      //model/...
+      
+   additional_languages:
+      # Uncomment any additional languages you want supported
+      # c
+      # dart
+      # kotlin
+      java
+      kotlin
 
-   - Select a preferred device definition. In general, any device is fine, but you can use Pixel 3a as a default (if you're developing for phones) or Nexus 7 (if you're developing for tablets). After selecting a device, click "Next" at the bottom right to continue.
-   - Select a system image (in general, API Level 28, unless you're an M1 Mac user, in which case use API Level 29). Then click "Next".
-   - Click "Finish" to complete setup.
+   # Please uncomment an android-SDK platform. Available SDKs are:
+      # android_sdk_platform: android-28
+      # android_sdk_platform: android-29
+      android_sdk_platform: android-30
+      # android_sdk_platform: android-31
+      # android_sdk_platform: android-32
+      # android_sdk_platform: android-33
+      android_sdk_platform: android-34
+   
+   shard_sync: true
+   
+   java_language_level: 11
+   ```
+   **Note**: Only enable Android-SDK platforms that you have installed per the [Prepare developer environment](#prepare-developer-environment) section above. Android-SDK platforms are useful for creating emulators to test your app with.
 
-2. To run the app, select the emulator device you want from the dropdown menu to the left of the "Run" button in the toolbar.
+8. Click **Create**, and allow the project to synchronize.
 
-3. Finally, click the "Run" button.
+9. Once sync has finished, you can now build and install the app on either a virtual or physical device. Bazel supports deploying to only one device at a time, so you can connect one device, or launch one emulator at a time.
+
+   You can run the project by using the Bazel plugin to set up run configurations for the target that you wish to build. This performs the same action as the run commands listed in the [Bazel user guide](https://github.com/oppia/oppia-android/wiki/Bazel-User-Guide), but using the GUI to run the app might be more intuitive for some developers.
+
+   ![Screenshot 2025-02-26 at 22 16 32](https://github.com/user-attachments/assets/f3be5288-dc96-4079-bcb2-b514de81f899)
+
+   Edit configurations allows us to specify the run command:
+
+   ![Image](https://github.com/user-attachments/assets/7270b6b3-11ac-4b49-a39a-734e0437bb9e)
+
+     - Target **Name**, is helpful for identifying the target from the list on the left.
+     - **Target expression** requires a build target such as `//:oppia_dev_binary`.
+     - **The Bazel command** is `mobile-install`
+     - **Bazel flags** are optional.
+     - Select **Apply** and then **Close** or **Ok**.
 
 ## Set up and run tests
 Testing the app is an integral part of our development process. You will need to test all code changes to ensure that the app works correctly, therefore it is important to ensure that your test configuration works.
 
-We strongly recommend running tests on Robolectric which is faster because it does not require a physical device or emulator setup.
+Our Bazel setup currently supports running tests on Robolectric which is fast because it does not require a physical device or emulator setup.
 
-### Configure Robolectric Tests
+We can run tests either through the UI supported by the Bazel Plugin, or via running a `bazel test` command on the terminal, i.e.:
 
-#### Step-by-Step guidance for setting up and running app modules robolectric test:
+> Tip 1: In order to get the correct path always, open the test file, then on the AS sidebar, right click on the file, and select `copy path/reference`. Then select `copy path from repository root`. Paste the copied path to terminal and remove the `.kt` extension. This can also be achieved by right clicking on the file tab if the test file is open and copy the copy path/reference.
 
-1. Go to **Edit Configuration** in Android Studio (Bumblebee | 2021.1.1 Patch 3)
-   ![](https://user-images.githubusercontent.com/9396084/79109714-83525980-7d96-11ea-99d7-f83ea81a8a50.png)
+   ```
+   bazel test full-path-of-test-file
+   ```
 
-2. Click on Add(+) -> **JUnit**
-   ![](https://github.com/oppia/oppia-android/assets/76530270/87caf3fc-37d9-472d-92fd-b8ec49fb6b49)
+e.g.
+   
+   ```
+   bazel test domain/src/test/java/org/oppia/android/domain/onboarding/AppStartupStateControllerTest
+   ```
 
-3. Enter following information:
-   - a) Name of test. Example: In my case "SplashActivityTest"
-   - b) Make sure select "java 11" and oppia-android.app
-   - c) Class path of Test class. Example: In my case "org.oppia.android.app.splash.
-   SplashActivityTest"
-   - d) Press `OK` to select the test.
-   ![](https://github.com/oppia/oppia-android/assets/76530270/5901624a-df76-4b27-8f31-6077a68fcb89)
+> Tip 2: You can pass a target argument to the `bazel test` command instead. Copy the relative path to the test file and query its target using `bazel query relative-path-of-test-file` e.g. `bazel query domain/src/test/java/org/oppia/android/domain/onboarding/AppStartupStateControllerTest.kt`. This will give you a Bazel target (i.e. starts with '//') --just copy that and remove the `.kt` at the end and you can pass it to `bazel test`, e.g.
 
-4. Click on "Run" button to run robolectric test. (In my case "SplashActivityTest")
-   ![](https://github.com/oppia/oppia-android/assets/76530270/75a6b998-90c5-4f0a-8886-78f96970be90)
+```
+bazel test //domain/src/test/java/org/oppia/android/domain/onboarding:AppStartupStateControllerTest
+```
 
-#### For tests that are in non-app modules, such as **domain** or **utility**::
+### Configure Robolectric Tests
+
+#### Step-by-Step guidance for setting up and running app module robolectric tests:
+
+1. In Android Studio, open the test file that you wish to run. If sync completed successfully when the project was opened, there will be a green run arrow next to the class name, as well as next to each individual test name. Clicking on the arrow will run either the full class or a single test as selected.
 
-1. In Android Studio, open the desired test file, e.g., `AnalyticsControllerTest`.
-2. In the test file, to the left of the class name, click on the orange and green arrow, and select **Run 'AnalyticsControllerTest'**.
-   - You will notice that the emulator is greyed out, but the run window will open to show the running tests:
-   ![](https://user-images.githubusercontent.com/59600948/272657015-158117e5-47d2-40fc-a38b-5dee6c347556.png)
+2. Because we have set up the Bazel plugin, we can also run a test class using the run arrow at the top of the project window:
 
-### Configure Emulator Tests
+   ![Screenshot 2025-02-26 at 22 16 32](https://github.com/user-attachments/assets/f3be5288-dc96-4079-bcb2-b514de81f899)
 
-**Espresso is slower for running tests, so we recommend using Robolectric.**
+   Edit configurations allows us to specify the run command:
+   ![Screenshot 2025-02-26 at 22 19 34](https://github.com/user-attachments/assets/462d07d2-4407-4898-bbc4-544509bd7486)
 
-1. In Android Studio, open the desired test file, e.g., `HomeActivityTest`.
-2. In the Android Studio toolbar, click on the `Available Devices` option. Select an emulator that has between API 28-30.
+   - Test **name**, is helpful for identifying the test target from the list on the left.
+   - **Target expression** requires the fully qualified path to the test file.
+   - **The Bazel command** for running tests is `test`
+   - **Bazel flags** are optional.
+   - Select **Apply** and then **Close** or **Ok**.
 
-   **Note**: If you don't have any available devices in this list, please follow [these instructions](#run-the-app-from-android-studio) to create one.
+#### For tests that are in non-app modules, such as **domain** or **utility**::
 
-3. In the test file, to the left of the class name, click on the orange and green arrow, and select **Run 'HomeActivityTest'**.
-   ![](https://user-images.githubusercontent.com/59600948/272657131-96e5354b-13a9-4709-969a-b9494a65c30f.png)
+1. In Android Studio, open the test file that you wish to run. If sync completed successfully when the project was opened, there will be a green run arrow next to the class name, as well as next to each individual test name. Clicking on the arrow will run either the full class or a single test as selected.
 
-4. An "**Edit Configuration**" dialog will show up, and you should add the following settings under the general tab:
-   - For module, select **oppia-android.app**
-   - For Test, select **Class**
-   - For Instrumentation class, **org.oppia.android.testing.OppiaTestRunner**, will be selected by default.
-   - For target, select the **Use the device/snapshot dropdown** option.
-   - Verify that your setup looks like below:
+2. A second way to run a test class would be to open the `BUILD` file located in the same package as the test file, and clicking on the green arrow next to the test target name.
+  
+   ![Image](https://github.com/user-attachments/assets/c1ee9e23-b0b2-430a-9592-9f87a2fdcbf0)
 
-     ![](https://user-images.githubusercontent.com/59600948/272657260-2e654891-61be-467a-8ebd-c997aa2abda6.png)
-- Finally, Click the "Apply" and "Okay" buttons.
-- You may need to repeat step (3) above to run the test with the new configuration.
-- Subsequent runs of any app module tests will not require editing the configuration.
-- This configuration will run all the tests in that class.
-5. To run only a specific test in a file:
-   - Search or scroll down to the desired test name, to the left of the test name, click on the run icon and select **Run '`test name`''**.
+3. The third way is to run a the test via CLI as mentioned above.
path: wiki/Installing-Oppia-Android.md
user: login: adhiamboperes
body: Included this info, but can now be found in the user guide.
created_at: 2025-03-18T20:14:30Z
author_association: CONTRIBUTOR
diff_hunk: @@ -0,0 +1,221 @@
+## Table of Contents
+
+- [Overview](#overview)
+- [Installation](#installation)
+  - [Building the app](#building-the-app)
+  - [Running specific module (app) Robolectric tests](#running-specific-module--app--robolectric-tests)
+  - [Running all Robolectric tests (slow)](#running-all-robolectric-tests--slow-)
+- [Concepts and Terminology](#concepts-and-terminology)
+- [Syncing the Project](#Syncing-the-project)
+
+## Overview
+Bazel is an open-source build and test tool similar to Make, Maven, and Gradle. It uses a human-readable, high-level build language.
+
+## Installation
+
+Follow the instructions on the [installation page](https://github.com/oppia/oppia-android/wiki/Installing-Oppia-Android#install-bazel) to set up Bazel.
+
+### Building the app
+
+The [installation page](https://github.com/oppia/oppia-android/wiki/Installing-Oppia-Android#install-bazel) provides information on running the project in Android Studio.
+
+You can also run the app from the command line using the commands detailed below.
+
+Using the command line is helpful in instances when you need to run some targets outside of Android Studio.
+
+Run the following commands in your terminal. All Bazel commands must be run from the root of the `oppia-android` directory otherwise they will fail.
+
+Note that on the first run, these commands may take 10-20 minutes to complete depending on the performance of your machine. Subsequent runs will be much faster.
+
+**On SDK 29 and below, run**:
+   ```
+   bazel mobile-install //:oppia_dev_binary
+   ```
+This will build, install and launch the app on your device.
+
+**On SDK 30 and newer, run**:
+   ```
+   bazel build //:oppia_dev
+   ```
+followed by:
+   ```
+   adb install bazel-bin/oppia_dev_binary.apk  
+   ```
+* Starting from Sdk 30, incremental builds, like those executed using `bazel mobile-install`, are no longer permitted, necessitating the use of two separate commands.
+
+If everything is working, you should see output like the following:
+
+```
+Target //:oppia_dev up-to-date:
+  bazel-bin/oppia_dev.aab
+INFO: Elapsed time: ...
+INFO: 1 process...
+INFO: Build completed successfully, ...
+```
+
+Note also that the ``oppia_dev.aab`` under the ``bazel-bin`` directory of your local copy of Oppia Android should be a fully functioning development version of the app that can be installed using bundle-tool. However, it's recommended to deploy Oppia to an emulator or connected device using the `mobile-install` command.
+
+### Running specific module (app) Robolectric tests
+
+```
+bazel test //app/...
+```
+
+### Running all Robolectric tests (slow)
+
+```
+bazel test //...
+```
+
+## Concepts and Terminology
+**[Workspace](https://github.com/oppia/oppia-android/blob/develop/WORKSPACE)**
+
+A workspace is a directory where we add targeted SDK version, all the required dependencies and there required Rules. The directory containing the WORKSPACE file is the root of the main repository, which in our case is the `oppia-android` root directory is the main directory.
path: wiki/Bazel-User-Guide.md
user: login: adhiamboperes
body: Done
created_at: 2025-03-18T20:16:09Z
author_association: CONTRIBUTOR
diff_hunk: @@ -5,32 +5,322 @@ This wiki page explains how to install Oppia Android on your local machine. If y
 ## Table of Contents
 
 - [Prepare developer environment](#prepare-developer-environment)
+- [install Bazel](#install-bazel)
path: wiki/Installing-Oppia-Android.md
user: login: BenHenning
body: ```suggestion
- [Install Bazel](#install-bazel)
```
created_at: 2025-03-18T23:13:24Z
author_association: MEMBER
diff_hunk: @@ -365,60 +374,55 @@ Please follow these steps to set up Oppia Android on your local machine.
 
    <img width="760" alt="Image" src="https://github.com/user-attachments/assets/5a26210f-865d-4048-b5a5-73379984bfb5" />
 
-7. In the above file, modify it so that it looks like below(copy and paste):
-   
-   ```
-   directories:
-      # Add the directories you want added as source here
-      # By default, we've added your entire workspace ('.')
-      .
-      
-   # Automatically includes all relevant targets under the 'directories' above
-   derive_targets_from_directories: false
-   
-   targets:
-   # If source code isn't resolving, add additional targets that compile it here
-      //:oppia_dev_binary
-      //app
-      //app/src/main/...
-      //domain/...
-      //model/...
-      //testing/...
-      //utility/...
-      //data/...
-      //scripts/...
-      
-   additional_languages:
-      # Uncomment any additional languages you want supported
-      # c
-      # dart
-      # kotlin
-      java
-      kotlin
-
-   # Please uncomment an android-SDK platform. Available SDKs are:
-      # android_sdk_platform: android-28
-      android_sdk_platform: android-29
-      # android_sdk_platform: android-30
-      # android_sdk_platform: android-31
-      # android_sdk_platform: android-32
-      # android_sdk_platform: android-33
-      android_sdk_platform: android-34
-   
-   shard_sync: true
-   sync_flags:
-      --local_ram_resources=HOST_RAM*.5
-      --discard_analysis_cache
+7. In the above file, modify it so that it looks like below (copy and paste):
    
-   java_language_level: 11
-   ```
+```
+directories:
path: wiki/Installing-Oppia-Android.md
user: login: BenHenning
body: Let's replace this with an `import` statement per #5762 and specifically https://ij.bazel.build/docs/project-views.html#import. I think that will look like this:

```
import oppia-android.bazelproject
```
created_at: 2025-03-18T23:24:34Z
author_association: MEMBER
diff_hunk: @@ -526,23 +481,33 @@ bazel test //domain/src/test/java/org/oppia/android/domain/onboarding:AppStartup
 
 - To learn about how we write tests at oppia-android, please refer to: [Oppia Android Testing](https://github.com/oppia/oppia-android/wiki/Oppia-Android-Testing).
 
-- To learn more about getting started with Bazel, please see [Oppia-Bazel-Glossary](https://github.com/oppia/oppia-android/wiki/Oppia-Bazel-Glossary).
+- To learn more about getting started with Bazel, please see the [Bazel User Guide](https://github.com/oppia/oppia-android/wiki/Bazel-User-Guide).
path: wiki/Installing-Oppia-Android.md
user: login: BenHenning
body: ```suggestion
- An important reference to go back to as you continue developing with Bazel is the [Bazel User Guide](https://github.com/oppia/oppia-android/wiki/Bazel-User-Guide).
```

'Getting started' sounds a bit too much like 'start here' which isn't correct--_this_ page is the actual starting place and the guide is just a long-term reference.
created_at: 2025-03-18T23:26:36Z
author_association: MEMBER
diff_hunk: @@ -0,0 +1,277 @@
+## Table of Contents
+
+- [Overview](#overview)
+- [Installation](#installation)
+  - [Building the app](#building-the-app)
+- [Running Tests](#running-tests)
+  - [How to Obtain a Test Target](#how-to-obtain-a-test-target)
+  - [Common Flags](#common-flags)
+  - [Running multiple test targets](#running-multiple-test-targets)
+- [Concepts and Terminology](#concepts-and-terminology)
+- [Syncing the Project](#Syncing-the-project)
path: wiki/Bazel-User-Guide.md
user: login: BenHenning
body: This doesn't seem linkified correctly--please fix.
created_at: 2025-03-18T23:29:27Z
author_association: MEMBER
diff_hunk: @@ -0,0 +1,277 @@
+## Table of Contents
+
+- [Overview](#overview)
+- [Installation](#installation)
+  - [Building the app](#building-the-app)
+- [Running Tests](#running-tests)
+  - [How to Obtain a Test Target](#how-to-obtain-a-test-target)
+  - [Common Flags](#common-flags)
+  - [Running multiple test targets](#running-multiple-test-targets)
+- [Concepts and Terminology](#concepts-and-terminology)
+- [Syncing the Project](#Syncing-the-project)
+
+## Overview
+Bazel is an open-source build and test tool similar to Make, Maven, and Gradle. It uses a human-readable, high-level build language.
+
+## Installation
+
+Follow the instructions on the [installation page](https://github.com/oppia/oppia-android/wiki/Installing-Oppia-Android#install-bazel) to set up Bazel.
+
+### Building the app
+
+The [installation page](https://github.com/oppia/oppia-android/wiki/Installing-Oppia-Android#install-bazel) provides information on running the project in Android Studio.
+
+You can also run the app from the command line using the commands detailed below.
+
+Using the command line is helpful in instances when you need to build and run some targets outside of Android Studio.
+
+Run the following commands in your terminal. All Bazel commands must be run from the root of the `oppia-android` directory otherwise they will fail.
+
+Note that on the first run, these commands may take 10-20 minutes to complete depending on the performance of your machine. Subsequent runs will be much faster.
+
+**On SDK 29 and below, run**:
+   ```
+   bazel mobile-install //:oppia_dev_binary
+   ```
+This will build, install and launch the app on your device.
+
+**On SDK 30 and newer, run**:
+   ```
+   bazel build //:oppia_dev
+   ```
+followed by:
+   ```
+   adb install bazel-bin/oppia_dev_binary.apk  
+   ```
+* Starting from Sdk 30, incremental builds, like those executed using `bazel mobile-install`, are no longer permitted, necessitating the use of two separate commands.
+
+If everything is working, you should see output like the following:
+
+```
+Target //:oppia_dev_binary up-to-date:
+  bazel-bin/oppia_dev_binary_deploy.jar
+  bazel-bin/oppia_dev_binary_unsigned.apk
+  bazel-bin/oppia_dev_binary.apk
+INFO: Elapsed time: 37.155s, Critical Path: 17.24s
+INFO: 99 processes: 2 internal, 23 darwin-sandbox, 74 worker.
+INFO: Build completed successfully, 99 total actions
+Performing Streamed Install
+Success
+```
+
+Note also that the ``oppia_dev.aab`` under the ``bazel-bin`` directory of your local copy of Oppia Android should be a fully functioning development version of the app that can be installed using bundle-tool. However, it's recommended to deploy Oppia to an emulator or connected device using the `mobile-install` command.
+
+## Running Tests
+
+The bazel test command is used to build and run tests in a Bazel workspace. It ensures that the specified test targets are built and executed in a sandboxed environment for reproducibility.
+
+**Syntax**
+
+```shell
+bazel test //path/to:target
+```
+
+### How to Obtain a Test Target
+A test target in Bazel refers to a specific testable entity defined in a BUILD file. It represents a test rule, such as `java_test` or `android_test`, that Bazel can build and execute.
+
+To ensure you always use the correct test target, follow one of these steps:
+1. If the test file is open in Android Studio:
+   * Right-click to open the context menu and select **Copy BUILD target string** as shown.
+     
+     ![Screenshot 2025-03-18 at 22 30 22](https://github.com/user-attachments/assets/286ebcb6-4f4e-4055-b6f0-4c070b039375)
+   
+   * Paste the target to the bazel test command, e.g. `bazel test //domain/src/test/java/org/oppia/android/domain/onboarding:AppStartupStateControllerTest`
+
+2. If the test file is open in Android Studio, but **Copy BUILD target string** is not available in the context menu:
+Sometimes the **Copy BUILD target string** is not available in the context menu either due to sync issues or modularization issues. You can still copy the file path, and pass it to the test command.
+   * In the AS sidebar, right click on the file, and select `copy path/reference`.
+     or
+   * Right-click on the file tab and then click `copy path/reference`.
+   * Next, select `copy path from repository root`. 
+   * Paste the copied path to the bazel test command in the terminal and remove the `.kt` extension, e.g. `bazel test domain/src/test/java/org/oppia/android/domain/onboarding/AppStartupStateControllerTest`.
+
+With this syntax, Bazel implicitly converts the file path into a target if it matches a test rule in the BUILD file. If the file is not part of a test target in the BUILD file, this command may fail.
+**When to use this**: If you are unsure about the exact Bazel target and want a quick way to run a test.
+
+3. Querying for a target
+Using the explicit Bazel target (// syntax) is more reliable compared to the file path syntax above. However, in cases such as running the test outside android studio, you may not know the target. In this case, you can use Bazel's `query` command to retrieve the correct test target:
+   * Copy the relative path of the test file.
+   * Run the following command in your terminal to get the test’s Bazel target: `bazel query relative-path-of-test-file`
+   Example
+   
+   ```shell
+   bazel query domain/src/test/java/org/oppia/android/domain/onboarding/AppStartupStateControllerTest.kt
+   ```
+   * The output will be a Bazel target that starts with //. Copy the target and remove the .kt extension.
+   * Use this target in the bazel test command, e.g. `bazel test //domain/src/test/java/org/oppia/android/domain/onboarding:AppStartupStateControllerTest`.
+
+### Common Flags
+
+`--test_output=all` → Show full test output.
+`--cache_test_results=no` → Force re-running tests even if cached.
+`--test_filter=ClassName#methodName` → Run specific test cases.
+
+### Running multiple test targets
path: wiki/Bazel-User-Guide.md
user: login: BenHenning
body: Another example to add: you can append multiple test targets to the same line, e.g.:

```sh
bazel test -- //path/to/target/OneTest //path/to/target/TwoTest
```
created_at: 2025-03-18T23:30:30Z
author_association: MEMBER
diff_hunk: @@ -0,0 +1,277 @@
+## Table of Contents
+
+- [Overview](#overview)
+- [Installation](#installation)
+  - [Building the app](#building-the-app)
+- [Running Tests](#running-tests)
+  - [How to Obtain a Test Target](#how-to-obtain-a-test-target)
+  - [Common Flags](#common-flags)
+  - [Running multiple test targets](#running-multiple-test-targets)
+- [Concepts and Terminology](#concepts-and-terminology)
+- [Syncing the Project](#Syncing-the-project)
+
+## Overview
+Bazel is an open-source build and test tool similar to Make, Maven, and Gradle. It uses a human-readable, high-level build language.
+
+## Installation
+
+Follow the instructions on the [installation page](https://github.com/oppia/oppia-android/wiki/Installing-Oppia-Android#install-bazel) to set up Bazel.
+
+### Building the app
+
+The [installation page](https://github.com/oppia/oppia-android/wiki/Installing-Oppia-Android#install-bazel) provides information on running the project in Android Studio.
+
+You can also run the app from the command line using the commands detailed below.
+
+Using the command line is helpful in instances when you need to build and run some targets outside of Android Studio.
+
+Run the following commands in your terminal. All Bazel commands must be run from the root of the `oppia-android` directory otherwise they will fail.
+
+Note that on the first run, these commands may take 10-20 minutes to complete depending on the performance of your machine. Subsequent runs will be much faster.
+
+**On SDK 29 and below, run**:
+   ```
+   bazel mobile-install //:oppia_dev_binary
+   ```
+This will build, install and launch the app on your device.
+
+**On SDK 30 and newer, run**:
+   ```
+   bazel build //:oppia_dev
+   ```
+followed by:
+   ```
+   adb install bazel-bin/oppia_dev_binary.apk  
+   ```
+* Starting from Sdk 30, incremental builds, like those executed using `bazel mobile-install`, are no longer permitted, necessitating the use of two separate commands.
+
+If everything is working, you should see output like the following:
+
+```
+Target //:oppia_dev_binary up-to-date:
+  bazel-bin/oppia_dev_binary_deploy.jar
+  bazel-bin/oppia_dev_binary_unsigned.apk
+  bazel-bin/oppia_dev_binary.apk
+INFO: Elapsed time: 37.155s, Critical Path: 17.24s
+INFO: 99 processes: 2 internal, 23 darwin-sandbox, 74 worker.
+INFO: Build completed successfully, 99 total actions
+Performing Streamed Install
+Success
+```
+
+Note also that the ``oppia_dev.aab`` under the ``bazel-bin`` directory of your local copy of Oppia Android should be a fully functioning development version of the app that can be installed using bundle-tool. However, it's recommended to deploy Oppia to an emulator or connected device using the `mobile-install` command.
+
+## Running Tests
+
+The bazel test command is used to build and run tests in a Bazel workspace. It ensures that the specified test targets are built and executed in a sandboxed environment for reproducibility.
+
+**Syntax**
+
+```shell
+bazel test //path/to:target
+```
+
+### How to Obtain a Test Target
+A test target in Bazel refers to a specific testable entity defined in a BUILD file. It represents a test rule, such as `java_test` or `android_test`, that Bazel can build and execute.
+
+To ensure you always use the correct test target, follow one of these steps:
+1. If the test file is open in Android Studio:
+   * Right-click to open the context menu and select **Copy BUILD target string** as shown.
+     
+     ![Screenshot 2025-03-18 at 22 30 22](https://github.com/user-attachments/assets/286ebcb6-4f4e-4055-b6f0-4c070b039375)
+   
+   * Paste the target to the bazel test command, e.g. `bazel test //domain/src/test/java/org/oppia/android/domain/onboarding:AppStartupStateControllerTest`
+
+2. If the test file is open in Android Studio, but **Copy BUILD target string** is not available in the context menu:
+Sometimes the **Copy BUILD target string** is not available in the context menu either due to sync issues or modularization issues. You can still copy the file path, and pass it to the test command.
+   * In the AS sidebar, right click on the file, and select `copy path/reference`.
+     or
+   * Right-click on the file tab and then click `copy path/reference`.
+   * Next, select `copy path from repository root`. 
+   * Paste the copied path to the bazel test command in the terminal and remove the `.kt` extension, e.g. `bazel test domain/src/test/java/org/oppia/android/domain/onboarding/AppStartupStateControllerTest`.
+
+With this syntax, Bazel implicitly converts the file path into a target if it matches a test rule in the BUILD file. If the file is not part of a test target in the BUILD file, this command may fail.
+**When to use this**: If you are unsure about the exact Bazel target and want a quick way to run a test.
+
+3. Querying for a target
+Using the explicit Bazel target (// syntax) is more reliable compared to the file path syntax above. However, in cases such as running the test outside android studio, you may not know the target. In this case, you can use Bazel's `query` command to retrieve the correct test target:
+   * Copy the relative path of the test file.
+   * Run the following command in your terminal to get the test’s Bazel target: `bazel query relative-path-of-test-file`
+   Example
+   
+   ```shell
+   bazel query domain/src/test/java/org/oppia/android/domain/onboarding/AppStartupStateControllerTest.kt
+   ```
+   * The output will be a Bazel target that starts with //. Copy the target and remove the .kt extension.
+   * Use this target in the bazel test command, e.g. `bazel test //domain/src/test/java/org/oppia/android/domain/onboarding:AppStartupStateControllerTest`.
+
+### Common Flags
+
+`--test_output=all` → Show full test output.
+`--cache_test_results=no` → Force re-running tests even if cached.
+`--test_filter=ClassName#methodName` → Run specific test cases.
+
+### Running multiple test targets
+To run all the test targets in the app module:
+
+```
+bazel test //app/...
+```
+
+To run all the test targets in the project (note that this would be extremely slow and is not recommended):
+
+```
+bazel test //...
+```
+
+## Concepts and Terminology
+**[Workspace](https://github.com/oppia/oppia-android/blob/develop/WORKSPACE)**
+
+A workspace is a directory where we specify the targeted SDK version, required dependencies, and corresponding Rules. The directory containing the WORKSPACE file is the root of the main repository, which in our case, is the `oppia-android` root directory.
+**[Packages](https://github.com/oppia/oppia-android/tree/develop/app)**
+
+A package is defined as a directory containing a file named BUILD or BUILD.bazel.
+
+**[Binary rules](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/BUILD.bazel#L3)**
+
+A rule specifies the relationship between inputs and outputs, and the steps to build the outputs.
+In Android, rules are defined using `android_binary`. Android rules for testing are `android_instrumentation_test` and `android_local_test`.
+
+**[BUILD files](https://github.com/oppia/oppia-android/blob/develop/app/BUILD.bazel)**
path: wiki/Bazel-User-Guide.md
user: login: BenHenning
body: Please permalink to this & the WORKSPACE files, too. Even these files aren't permanent and will probably disappear one day (app's eventually with modularization maturity and WORKSPACE when we migrate to Bazel 8.x).
created_at: 2025-03-18T23:31:25Z
author_association: MEMBER
diff_hunk: @@ -0,0 +1,277 @@
+## Table of Contents
+
+- [Overview](#overview)
+- [Installation](#installation)
+  - [Building the app](#building-the-app)
+- [Running Tests](#running-tests)
+  - [How to Obtain a Test Target](#how-to-obtain-a-test-target)
+  - [Common Flags](#common-flags)
+  - [Running multiple test targets](#running-multiple-test-targets)
+- [Concepts and Terminology](#concepts-and-terminology)
+- [Syncing the Project](#Syncing-the-project)
+
+## Overview
+Bazel is an open-source build and test tool similar to Make, Maven, and Gradle. It uses a human-readable, high-level build language.
+
+## Installation
+
+Follow the instructions on the [installation page](https://github.com/oppia/oppia-android/wiki/Installing-Oppia-Android#install-bazel) to set up Bazel.
+
+### Building the app
+
+The [installation page](https://github.com/oppia/oppia-android/wiki/Installing-Oppia-Android#install-bazel) provides information on running the project in Android Studio.
+
+You can also run the app from the command line using the commands detailed below.
+
+Using the command line is helpful in instances when you need to build and run some targets outside of Android Studio.
+
+Run the following commands in your terminal. All Bazel commands must be run from the root of the `oppia-android` directory otherwise they will fail.
+
+Note that on the first run, these commands may take 10-20 minutes to complete depending on the performance of your machine. Subsequent runs will be much faster.
+
+**On SDK 29 and below, run**:
+   ```
+   bazel mobile-install //:oppia_dev_binary
+   ```
+This will build, install and launch the app on your device.
+
+**On SDK 30 and newer, run**:
+   ```
+   bazel build //:oppia_dev
+   ```
+followed by:
+   ```
+   adb install bazel-bin/oppia_dev_binary.apk  
+   ```
+* Starting from Sdk 30, incremental builds, like those executed using `bazel mobile-install`, are no longer permitted, necessitating the use of two separate commands.
+
+If everything is working, you should see output like the following:
+
+```
+Target //:oppia_dev_binary up-to-date:
+  bazel-bin/oppia_dev_binary_deploy.jar
+  bazel-bin/oppia_dev_binary_unsigned.apk
+  bazel-bin/oppia_dev_binary.apk
+INFO: Elapsed time: 37.155s, Critical Path: 17.24s
+INFO: 99 processes: 2 internal, 23 darwin-sandbox, 74 worker.
+INFO: Build completed successfully, 99 total actions
+Performing Streamed Install
+Success
+```
+
+Note also that the ``oppia_dev.aab`` under the ``bazel-bin`` directory of your local copy of Oppia Android should be a fully functioning development version of the app that can be installed using bundle-tool. However, it's recommended to deploy Oppia to an emulator or connected device using the `mobile-install` command.
+
+## Running Tests
+
+The bazel test command is used to build and run tests in a Bazel workspace. It ensures that the specified test targets are built and executed in a sandboxed environment for reproducibility.
+
+**Syntax**
+
+```shell
+bazel test //path/to:target
+```
+
+### How to Obtain a Test Target
+A test target in Bazel refers to a specific testable entity defined in a BUILD file. It represents a test rule, such as `java_test` or `android_test`, that Bazel can build and execute.
+
+To ensure you always use the correct test target, follow one of these steps:
+1. If the test file is open in Android Studio:
+   * Right-click to open the context menu and select **Copy BUILD target string** as shown.
+     
+     ![Screenshot 2025-03-18 at 22 30 22](https://github.com/user-attachments/assets/286ebcb6-4f4e-4055-b6f0-4c070b039375)
+   
+   * Paste the target to the bazel test command, e.g. `bazel test //domain/src/test/java/org/oppia/android/domain/onboarding:AppStartupStateControllerTest`
+
+2. If the test file is open in Android Studio, but **Copy BUILD target string** is not available in the context menu:
+Sometimes the **Copy BUILD target string** is not available in the context menu either due to sync issues or modularization issues. You can still copy the file path, and pass it to the test command.
+   * In the AS sidebar, right click on the file, and select `copy path/reference`.
+     or
+   * Right-click on the file tab and then click `copy path/reference`.
+   * Next, select `copy path from repository root`. 
+   * Paste the copied path to the bazel test command in the terminal and remove the `.kt` extension, e.g. `bazel test domain/src/test/java/org/oppia/android/domain/onboarding/AppStartupStateControllerTest`.
+
+With this syntax, Bazel implicitly converts the file path into a target if it matches a test rule in the BUILD file. If the file is not part of a test target in the BUILD file, this command may fail.
+**When to use this**: If you are unsure about the exact Bazel target and want a quick way to run a test.
+
+3. Querying for a target
+Using the explicit Bazel target (// syntax) is more reliable compared to the file path syntax above. However, in cases such as running the test outside android studio, you may not know the target. In this case, you can use Bazel's `query` command to retrieve the correct test target:
+   * Copy the relative path of the test file.
+   * Run the following command in your terminal to get the test’s Bazel target: `bazel query relative-path-of-test-file`
+   Example
+   
+   ```shell
+   bazel query domain/src/test/java/org/oppia/android/domain/onboarding/AppStartupStateControllerTest.kt
+   ```
+   * The output will be a Bazel target that starts with //. Copy the target and remove the .kt extension.
+   * Use this target in the bazel test command, e.g. `bazel test //domain/src/test/java/org/oppia/android/domain/onboarding:AppStartupStateControllerTest`.
+
+### Common Flags
path: wiki/Bazel-User-Guide.md
user: login: BenHenning
body: Another good flag to add: `--runs_per_test` to test multiple runs: https://bazel.build/reference/command-line-reference#flag--runs_per_test.
created_at: 2025-03-18T23:32:16Z
author_association: MEMBER
diff_hunk: @@ -0,0 +1,277 @@
+## Table of Contents
+
+- [Overview](#overview)
+- [Installation](#installation)
+  - [Building the app](#building-the-app)
+- [Running Tests](#running-tests)
+  - [How to Obtain a Test Target](#how-to-obtain-a-test-target)
+  - [Common Flags](#common-flags)
+  - [Running multiple test targets](#running-multiple-test-targets)
+- [Concepts and Terminology](#concepts-and-terminology)
+- [Syncing the Project](#Syncing-the-project)
+
+## Overview
+Bazel is an open-source build and test tool similar to Make, Maven, and Gradle. It uses a human-readable, high-level build language.
+
+## Installation
+
+Follow the instructions on the [installation page](https://github.com/oppia/oppia-android/wiki/Installing-Oppia-Android#install-bazel) to set up Bazel.
+
+### Building the app
+
+The [installation page](https://github.com/oppia/oppia-android/wiki/Installing-Oppia-Android#install-bazel) provides information on running the project in Android Studio.
+
+You can also run the app from the command line using the commands detailed below.
+
+Using the command line is helpful in instances when you need to build and run some targets outside of Android Studio.
+
+Run the following commands in your terminal. All Bazel commands must be run from the root of the `oppia-android` directory otherwise they will fail.
+
+Note that on the first run, these commands may take 10-20 minutes to complete depending on the performance of your machine. Subsequent runs will be much faster.
+
+**On SDK 29 and below, run**:
+   ```
+   bazel mobile-install //:oppia_dev_binary
+   ```
+This will build, install and launch the app on your device.
+
+**On SDK 30 and newer, run**:
+   ```
+   bazel build //:oppia_dev
+   ```
+followed by:
+   ```
+   adb install bazel-bin/oppia_dev_binary.apk  
+   ```
+* Starting from Sdk 30, incremental builds, like those executed using `bazel mobile-install`, are no longer permitted, necessitating the use of two separate commands.
+
+If everything is working, you should see output like the following:
+
+```
+Target //:oppia_dev_binary up-to-date:
+  bazel-bin/oppia_dev_binary_deploy.jar
+  bazel-bin/oppia_dev_binary_unsigned.apk
+  bazel-bin/oppia_dev_binary.apk
+INFO: Elapsed time: 37.155s, Critical Path: 17.24s
+INFO: 99 processes: 2 internal, 23 darwin-sandbox, 74 worker.
+INFO: Build completed successfully, 99 total actions
+Performing Streamed Install
+Success
+```
+
+Note also that the ``oppia_dev.aab`` under the ``bazel-bin`` directory of your local copy of Oppia Android should be a fully functioning development version of the app that can be installed using bundle-tool. However, it's recommended to deploy Oppia to an emulator or connected device using the `mobile-install` command.
+
+## Running Tests
+
+The bazel test command is used to build and run tests in a Bazel workspace. It ensures that the specified test targets are built and executed in a sandboxed environment for reproducibility.
+
+**Syntax**
+
+```shell
+bazel test //path/to:target
+```
+
+### How to Obtain a Test Target
+A test target in Bazel refers to a specific testable entity defined in a BUILD file. It represents a test rule, such as `java_test` or `android_test`, that Bazel can build and execute.
+
+To ensure you always use the correct test target, follow one of these steps:
+1. If the test file is open in Android Studio:
+   * Right-click to open the context menu and select **Copy BUILD target string** as shown.
+     
+     ![Screenshot 2025-03-18 at 22 30 22](https://github.com/user-attachments/assets/286ebcb6-4f4e-4055-b6f0-4c070b039375)
+   
+   * Paste the target to the bazel test command, e.g. `bazel test //domain/src/test/java/org/oppia/android/domain/onboarding:AppStartupStateControllerTest`
+
+2. If the test file is open in Android Studio, but **Copy BUILD target string** is not available in the context menu:
+Sometimes the **Copy BUILD target string** is not available in the context menu either due to sync issues or modularization issues. You can still copy the file path, and pass it to the test command.
+   * In the AS sidebar, right click on the file, and select `copy path/reference`.
+     or
+   * Right-click on the file tab and then click `copy path/reference`.
+   * Next, select `copy path from repository root`. 
+   * Paste the copied path to the bazel test command in the terminal and remove the `.kt` extension, e.g. `bazel test domain/src/test/java/org/oppia/android/domain/onboarding/AppStartupStateControllerTest`.
+
+With this syntax, Bazel implicitly converts the file path into a target if it matches a test rule in the BUILD file. If the file is not part of a test target in the BUILD file, this command may fail.
+**When to use this**: If you are unsure about the exact Bazel target and want a quick way to run a test.
+
+3. Querying for a target
+Using the explicit Bazel target (// syntax) is more reliable compared to the file path syntax above. However, in cases such as running the test outside android studio, you may not know the target. In this case, you can use Bazel's `query` command to retrieve the correct test target:
+   * Copy the relative path of the test file.
+   * Run the following command in your terminal to get the test’s Bazel target: `bazel query relative-path-of-test-file`
+   Example
+   
+   ```shell
+   bazel query domain/src/test/java/org/oppia/android/domain/onboarding/AppStartupStateControllerTest.kt
+   ```
+   * The output will be a Bazel target that starts with //. Copy the target and remove the .kt extension.
+   * Use this target in the bazel test command, e.g. `bazel test //domain/src/test/java/org/oppia/android/domain/onboarding:AppStartupStateControllerTest`.
+
+### Common Flags
+
+`--test_output=all` → Show full test output.
+`--cache_test_results=no` → Force re-running tests even if cached.
+`--test_filter=ClassName#methodName` → Run specific test cases.
+
+### Running multiple test targets
+To run all the test targets in the app module:
+
+```
+bazel test //app/...
+```
+
+To run all the test targets in the project (note that this would be extremely slow and is not recommended):
+
+```
+bazel test //...
+```
+
+## Concepts and Terminology
+**[Workspace](https://github.com/oppia/oppia-android/blob/develop/WORKSPACE)**
+
+A workspace is a directory where we specify the targeted SDK version, required dependencies, and corresponding Rules. The directory containing the WORKSPACE file is the root of the main repository, which in our case, is the `oppia-android` root directory.
+**[Packages](https://github.com/oppia/oppia-android/tree/develop/app)**
+
+A package is defined as a directory containing a file named BUILD or BUILD.bazel.
+
+**[Binary rules](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/BUILD.bazel#L3)**
+
+A rule specifies the relationship between inputs and outputs, and the steps to build the outputs.
+In Android, rules are defined using `android_binary`. Android rules for testing are `android_instrumentation_test` and `android_local_test`.
+
+**[BUILD files](https://github.com/oppia/oppia-android/blob/develop/app/BUILD.bazel)**
+
+Every package contains a BUILD file. This file is written in Starlark Language. In this Build file for module-level, we generally define `android_library`, `kt_android_library` to build our package files as per the requirement.
+
+**[Dependencies](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/BUILD.bazel#L16)**
+
+A target A depends upon a target B if B is needed by A at build. `A -> B`
+
+```
+deps = [ "//app",]
+```
+Here, `deps` is used to define the dependencies which is a type of dependencies called `deps dependencies` and it includes the files/directory/target which are dependent. From the above example the dependency is the `app` target which is defined in the [Build file of app package](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/app/BUILD.bazel#L616).
+
+Example of Dependencies
+1. [srcs dependencies](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/app/BUILD.bazel#L617)
+2. [deps dependencies](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/app/BUILD.bazel#L622)
+
+**[Loading an extension](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/app/BUILD.bazel#L13)**
+
+Bazel extensions are files ending in .bzl. Use the load statement to import a symbol from an extension.
+
+```
+load("@io_bazel_rules_kotlin//kotlin:android.bzl", "kt_android_library")
+```
+Here, we are loading `android.bzl` and we are going to use it with a symbol name `kt_android_library`.
+Arguments to the load function must be string literals. load statements must appear at top-level in the file.
+
+**[Visibility of a file target](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/app/BUILD.bazel#L621)**
+
+With the example from our codebase, target `app` whose visibility is public. 
+
+ - `visibility = ["//visibility:public"],` - Anyone can use this target.
+ - `"//visibility:private"` - Only targets in this package can use this target.
+
+**[Testing](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/app/BUILD.bazel#L719)**
path: wiki/Bazel-User-Guide.md
user: login: BenHenning
body: Can we update this to point to an oppia_android_test now that app_test was removed? I missed it in my PR since there wasn't an easy way to find this reference.
created_at: 2025-03-18T23:33:10Z
author_association: MEMBER
diff_hunk: @@ -0,0 +1,277 @@
+## Table of Contents
+
+- [Overview](#overview)
+- [Installation](#installation)
+  - [Building the app](#building-the-app)
+- [Running Tests](#running-tests)
+  - [How to Obtain a Test Target](#how-to-obtain-a-test-target)
+  - [Common Flags](#common-flags)
+  - [Running multiple test targets](#running-multiple-test-targets)
+- [Concepts and Terminology](#concepts-and-terminology)
+- [Syncing the Project](#Syncing-the-project)
+
+## Overview
+Bazel is an open-source build and test tool similar to Make, Maven, and Gradle. It uses a human-readable, high-level build language.
+
+## Installation
+
+Follow the instructions on the [installation page](https://github.com/oppia/oppia-android/wiki/Installing-Oppia-Android#install-bazel) to set up Bazel.
+
+### Building the app
+
+The [installation page](https://github.com/oppia/oppia-android/wiki/Installing-Oppia-Android#install-bazel) provides information on running the project in Android Studio.
+
+You can also run the app from the command line using the commands detailed below.
+
+Using the command line is helpful in instances when you need to build and run some targets outside of Android Studio.
+
+Run the following commands in your terminal. All Bazel commands must be run from the root of the `oppia-android` directory otherwise they will fail.
+
+Note that on the first run, these commands may take 10-20 minutes to complete depending on the performance of your machine. Subsequent runs will be much faster.
+
+**On SDK 29 and below, run**:
+   ```
+   bazel mobile-install //:oppia_dev_binary
+   ```
+This will build, install and launch the app on your device.
+
+**On SDK 30 and newer, run**:
+   ```
+   bazel build //:oppia_dev
+   ```
+followed by:
+   ```
+   adb install bazel-bin/oppia_dev_binary.apk  
+   ```
+* Starting from Sdk 30, incremental builds, like those executed using `bazel mobile-install`, are no longer permitted, necessitating the use of two separate commands.
+
+If everything is working, you should see output like the following:
+
+```
+Target //:oppia_dev_binary up-to-date:
+  bazel-bin/oppia_dev_binary_deploy.jar
+  bazel-bin/oppia_dev_binary_unsigned.apk
+  bazel-bin/oppia_dev_binary.apk
+INFO: Elapsed time: 37.155s, Critical Path: 17.24s
+INFO: 99 processes: 2 internal, 23 darwin-sandbox, 74 worker.
+INFO: Build completed successfully, 99 total actions
+Performing Streamed Install
+Success
+```
+
+Note also that the ``oppia_dev.aab`` under the ``bazel-bin`` directory of your local copy of Oppia Android should be a fully functioning development version of the app that can be installed using bundle-tool. However, it's recommended to deploy Oppia to an emulator or connected device using the `mobile-install` command.
+
+## Running Tests
+
+The bazel test command is used to build and run tests in a Bazel workspace. It ensures that the specified test targets are built and executed in a sandboxed environment for reproducibility.
+
+**Syntax**
+
+```shell
+bazel test //path/to:target
+```
+
+### How to Obtain a Test Target
+A test target in Bazel refers to a specific testable entity defined in a BUILD file. It represents a test rule, such as `java_test` or `android_test`, that Bazel can build and execute.
+
+To ensure you always use the correct test target, follow one of these steps:
+1. If the test file is open in Android Studio:
+   * Right-click to open the context menu and select **Copy BUILD target string** as shown.
+     
+     ![Screenshot 2025-03-18 at 22 30 22](https://github.com/user-attachments/assets/286ebcb6-4f4e-4055-b6f0-4c070b039375)
+   
+   * Paste the target to the bazel test command, e.g. `bazel test //domain/src/test/java/org/oppia/android/domain/onboarding:AppStartupStateControllerTest`
+
+2. If the test file is open in Android Studio, but **Copy BUILD target string** is not available in the context menu:
+Sometimes the **Copy BUILD target string** is not available in the context menu either due to sync issues or modularization issues. You can still copy the file path, and pass it to the test command.
+   * In the AS sidebar, right click on the file, and select `copy path/reference`.
+     or
+   * Right-click on the file tab and then click `copy path/reference`.
+   * Next, select `copy path from repository root`. 
+   * Paste the copied path to the bazel test command in the terminal and remove the `.kt` extension, e.g. `bazel test domain/src/test/java/org/oppia/android/domain/onboarding/AppStartupStateControllerTest`.
+
+With this syntax, Bazel implicitly converts the file path into a target if it matches a test rule in the BUILD file. If the file is not part of a test target in the BUILD file, this command may fail.
+**When to use this**: If you are unsure about the exact Bazel target and want a quick way to run a test.
+
+3. Querying for a target
+Using the explicit Bazel target (// syntax) is more reliable compared to the file path syntax above. However, in cases such as running the test outside android studio, you may not know the target. In this case, you can use Bazel's `query` command to retrieve the correct test target:
+   * Copy the relative path of the test file.
+   * Run the following command in your terminal to get the test’s Bazel target: `bazel query relative-path-of-test-file`
+   Example
+   
+   ```shell
+   bazel query domain/src/test/java/org/oppia/android/domain/onboarding/AppStartupStateControllerTest.kt
+   ```
+   * The output will be a Bazel target that starts with //. Copy the target and remove the .kt extension.
+   * Use this target in the bazel test command, e.g. `bazel test //domain/src/test/java/org/oppia/android/domain/onboarding:AppStartupStateControllerTest`.
+
+### Common Flags
+
+`--test_output=all` → Show full test output.
+`--cache_test_results=no` → Force re-running tests even if cached.
+`--test_filter=ClassName#methodName` → Run specific test cases.
+
+### Running multiple test targets
+To run all the test targets in the app module:
+
+```
+bazel test //app/...
+```
+
+To run all the test targets in the project (note that this would be extremely slow and is not recommended):
+
+```
+bazel test //...
+```
+
+## Concepts and Terminology
+**[Workspace](https://github.com/oppia/oppia-android/blob/develop/WORKSPACE)**
+
+A workspace is a directory where we specify the targeted SDK version, required dependencies, and corresponding Rules. The directory containing the WORKSPACE file is the root of the main repository, which in our case, is the `oppia-android` root directory.
+**[Packages](https://github.com/oppia/oppia-android/tree/develop/app)**
+
+A package is defined as a directory containing a file named BUILD or BUILD.bazel.
+
+**[Binary rules](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/BUILD.bazel#L3)**
+
+A rule specifies the relationship between inputs and outputs, and the steps to build the outputs.
+In Android, rules are defined using `android_binary`. Android rules for testing are `android_instrumentation_test` and `android_local_test`.
+
+**[BUILD files](https://github.com/oppia/oppia-android/blob/develop/app/BUILD.bazel)**
+
+Every package contains a BUILD file. This file is written in Starlark Language. In this Build file for module-level, we generally define `android_library`, `kt_android_library` to build our package files as per the requirement.
+
+**[Dependencies](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/BUILD.bazel#L16)**
+
+A target A depends upon a target B if B is needed by A at build. `A -> B`
+
+```
+deps = [ "//app",]
+```
+Here, `deps` is used to define the dependencies which is a type of dependencies called `deps dependencies` and it includes the files/directory/target which are dependent. From the above example the dependency is the `app` target which is defined in the [Build file of app package](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/app/BUILD.bazel#L616).
+
+Example of Dependencies
+1. [srcs dependencies](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/app/BUILD.bazel#L617)
+2. [deps dependencies](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/app/BUILD.bazel#L622)
+
+**[Loading an extension](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/app/BUILD.bazel#L13)**
+
+Bazel extensions are files ending in .bzl. Use the load statement to import a symbol from an extension.
+
+```
+load("@io_bazel_rules_kotlin//kotlin:android.bzl", "kt_android_library")
+```
+Here, we are loading `android.bzl` and we are going to use it with a symbol name `kt_android_library`.
+Arguments to the load function must be string literals. load statements must appear at top-level in the file.
+
+**[Visibility of a file target](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/app/BUILD.bazel#L621)**
+
+With the example from our codebase, target `app` whose visibility is public. 
+
+ - `visibility = ["//visibility:public"],` - Anyone can use this target.
+ - `"//visibility:private"` - Only targets in this package can use this target.
+
+**[Testing](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/app/BUILD.bazel#L719)**
+
+when we want to run test cases on Bazel build environment, a test target needs to be set up correctly:
+
+```bazel
+load("//:oppia_android_test.bzl", "oppia_android_test")
+
+oppia_android_test(
+    name = "MathExpressionInteractionsViewTest",
+    srcs = [
+        "MathExpressionInteractionsViewTest.kt",
+        "//app:data_binder_mapper_impl"
+    ],
+    custom_package = "org.oppia.android.app.test",
+    test_manifest = "//app:test_manifest",
+    enable_data_binding = True,
+    test_class = "org.oppia.android.app.customview.interaction.MathExpressionInteractionsViewTest",
+    deps = [
+      ...
+    ],
+)
+```
+
+The above assumes that the corresponding test requires resources. If it doesn't, the definition can be a bit simpler:
+
+```bazel
+load("//:oppia_android_test.bzl", "oppia_android_test")
+
+oppia_android_test(
+    name = "MathExpressionAccessibilityUtilTest",
+    srcs = ["MathExpressionAccessibilityUtilTest.kt"],
+    custom_package = "org.oppia.android.app.utility.math",
+    test_class = "org.oppia.android.app.utility.math.MathExpressionAccessibilityUtilTest",
+    test_manifest = "//app:test_manifest",
+    deps = [
+      ...
+    ],
path: wiki/Bazel-User-Guide.md
user: login: BenHenning
body: Can we make sure the order here is consistent between this block and the one above? Also, they should follow whatever buildifier enforces.
created_at: 2025-03-18T23:34:24Z
author_association: MEMBER
diff_hunk: @@ -0,0 +1,277 @@
+## Table of Contents
+
+- [Overview](#overview)
+- [Installation](#installation)
+  - [Building the app](#building-the-app)
+- [Running Tests](#running-tests)
+  - [How to Obtain a Test Target](#how-to-obtain-a-test-target)
+  - [Common Flags](#common-flags)
+  - [Running multiple test targets](#running-multiple-test-targets)
+- [Concepts and Terminology](#concepts-and-terminology)
+- [Syncing the Project](#Syncing-the-project)
+
+## Overview
+Bazel is an open-source build and test tool similar to Make, Maven, and Gradle. It uses a human-readable, high-level build language.
+
+## Installation
+
+Follow the instructions on the [installation page](https://github.com/oppia/oppia-android/wiki/Installing-Oppia-Android#install-bazel) to set up Bazel.
+
+### Building the app
+
+The [installation page](https://github.com/oppia/oppia-android/wiki/Installing-Oppia-Android#install-bazel) provides information on running the project in Android Studio.
+
+You can also run the app from the command line using the commands detailed below.
+
+Using the command line is helpful in instances when you need to build and run some targets outside of Android Studio.
+
+Run the following commands in your terminal. All Bazel commands must be run from the root of the `oppia-android` directory otherwise they will fail.
+
+Note that on the first run, these commands may take 10-20 minutes to complete depending on the performance of your machine. Subsequent runs will be much faster.
+
+**On SDK 29 and below, run**:
+   ```
+   bazel mobile-install //:oppia_dev_binary
+   ```
+This will build, install and launch the app on your device.
+
+**On SDK 30 and newer, run**:
+   ```
+   bazel build //:oppia_dev
+   ```
+followed by:
+   ```
+   adb install bazel-bin/oppia_dev_binary.apk  
+   ```
+* Starting from Sdk 30, incremental builds, like those executed using `bazel mobile-install`, are no longer permitted, necessitating the use of two separate commands.
path: wiki/Bazel-User-Guide.md
user: login: BenHenning
body: Another case for `SDK`. Perhaps do a quick search across the wiki to ensure consistency?
created_at: 2025-03-18T23:37:05Z
author_association: MEMBER
diff_hunk: @@ -5,32 +5,322 @@ This wiki page explains how to install Oppia Android on your local machine. If y
 ## Table of Contents
 
 - [Prepare developer environment](#prepare-developer-environment)
+- [install Bazel](#install-bazel)
+  - [Bazel Set up for Mac](#bazel-set-up-for-mac)
+  - [Bazel Set up for Linux](#bazel-set-up-for-linux)
+  - [Bazel Set up for Windows](#bazel-set-up-for-windows)
 - [Install oppia-android](#install-oppia-android)
-- [Run the app from Android Studio](#run-the-app-from-android-studio)
+- [Opening the Project in Android Studio](#opening-the-project-in-android-studio)
 - [Set up and Run tests](#set-up-and-run-tests)
-  - [Step-by-Step guidance for setting up and running app modules robolectric test](#step-by-step-guidance-for-setting-up-and-running-app-modules-robolectric-test)
-  - [For tests that are in non-app modules, such as **domain** or **utility**:](#for-tests-that-are-in-non-app-modules-such-as-domain-or-utility)
-
+  - [Running app module tests](#running-app-module-tests)
+  - [Running non-app module tests](#running-non-app-module-tests)
+- [Next Steps](#next-steps)
+- [Troubleshooting Installation](#troubleshooting-installation)
 
 ## Prepare developer environment
 
-1. Download/Install [Android Studio Bumblebee | Patch 3](https://developer.android.com/studio/archive).
+1. Download and install Android Studio **Giraffe** from [this location](https://developer.android.com/studio/archive).
+   **Note**: You may try newer or older versions of Android Studio, but we can't guarantee good support.
 
-   **Note**: We recommend installing **Android Studio Bumblebee | 2021.1.1 Patch 3** because newer versions of Android Studio[ do not support running tests where shared source sets are used](https://issuetracker.google.com/issues/232007221#comment18), a configuration we use at Oppia.
+2. Configure your Android Studio
+   - From your PC's application menu, open Android Studio. 
+   - On the welcome screen, find the "more options menu" and select **SDK Manager**
+     
+     <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/efcc4e6e-b6ba-44fc-9c96-aa381de83911" />
+    
+   - In the "SDK Platforms" tab (which is the default), select `API Level 30` and also `API Level 34`.
+   - Also, navigate to the "SDK Tools" tab, click the "Show Package Details" checkbox at the bottom right, then click on "Android SDK Build-Tools 34-rc1" and select 32.0.0 (this is needed for Bazel support).
 
-   **Direct download Url**: [Windows](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-windows.exe) | [Linux](https://redirector.gvt1.com/edgedl/android/studio/ide-zips/2021.1.1.23/android-studio-2021.1.1.23-linux.tar.gz) | [Intel Mac](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-mac.dmg) | [Apple Silicon Mac](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-mac_arm.dmg)
+   - Then, click "Apply" to download and install these two SDKs/Tools.
+     - On this screen, note the **Android SDK Location**, which is set as the ANDROID_HOME variable in  the Bazel setup step below.
path: wiki/Installing-Oppia-Android.md
user: login: BenHenning
body: ```suggestion
     - On this screen, note the **Android SDK Location**, which is set as the ANDROID_HOME variable in the Bazel setup step below.
```

Spotted an extra space.
created_at: 2025-03-18T23:41:51Z
author_association: MEMBER
diff_hunk: @@ -5,32 +5,322 @@ This wiki page explains how to install Oppia Android on your local machine. If y
 ## Table of Contents
 
 - [Prepare developer environment](#prepare-developer-environment)
+- [install Bazel](#install-bazel)
path: wiki/Installing-Oppia-Android.md
user: login: adhiamboperes
body: Done.
created_at: 2025-03-19T14:54:13Z
author_association: CONTRIBUTOR
diff_hunk: @@ -526,23 +481,33 @@ bazel test //domain/src/test/java/org/oppia/android/domain/onboarding:AppStartup
 
 - To learn about how we write tests at oppia-android, please refer to: [Oppia Android Testing](https://github.com/oppia/oppia-android/wiki/Oppia-Android-Testing).
 
-- To learn more about getting started with Bazel, please see [Oppia-Bazel-Glossary](https://github.com/oppia/oppia-android/wiki/Oppia-Bazel-Glossary).
+- To learn more about getting started with Bazel, please see the [Bazel User Guide](https://github.com/oppia/oppia-android/wiki/Bazel-User-Guide).
path: wiki/Installing-Oppia-Android.md
user: login: adhiamboperes
body: Done.
created_at: 2025-03-19T14:56:34Z
author_association: CONTRIBUTOR
diff_hunk: @@ -0,0 +1,277 @@
+## Table of Contents
+
+- [Overview](#overview)
+- [Installation](#installation)
+  - [Building the app](#building-the-app)
+- [Running Tests](#running-tests)
+  - [How to Obtain a Test Target](#how-to-obtain-a-test-target)
+  - [Common Flags](#common-flags)
+  - [Running multiple test targets](#running-multiple-test-targets)
+- [Concepts and Terminology](#concepts-and-terminology)
+- [Syncing the Project](#Syncing-the-project)
path: wiki/Bazel-User-Guide.md
user: login: adhiamboperes
body: Fixed.
created_at: 2025-03-19T14:57:10Z
author_association: CONTRIBUTOR
diff_hunk: @@ -0,0 +1,277 @@
+## Table of Contents
+
+- [Overview](#overview)
+- [Installation](#installation)
+  - [Building the app](#building-the-app)
+- [Running Tests](#running-tests)
+  - [How to Obtain a Test Target](#how-to-obtain-a-test-target)
+  - [Common Flags](#common-flags)
+  - [Running multiple test targets](#running-multiple-test-targets)
+- [Concepts and Terminology](#concepts-and-terminology)
+- [Syncing the Project](#Syncing-the-project)
+
+## Overview
+Bazel is an open-source build and test tool similar to Make, Maven, and Gradle. It uses a human-readable, high-level build language.
+
+## Installation
+
+Follow the instructions on the [installation page](https://github.com/oppia/oppia-android/wiki/Installing-Oppia-Android#install-bazel) to set up Bazel.
+
+### Building the app
+
+The [installation page](https://github.com/oppia/oppia-android/wiki/Installing-Oppia-Android#install-bazel) provides information on running the project in Android Studio.
+
+You can also run the app from the command line using the commands detailed below.
+
+Using the command line is helpful in instances when you need to build and run some targets outside of Android Studio.
+
+Run the following commands in your terminal. All Bazel commands must be run from the root of the `oppia-android` directory otherwise they will fail.
+
+Note that on the first run, these commands may take 10-20 minutes to complete depending on the performance of your machine. Subsequent runs will be much faster.
+
+**On SDK 29 and below, run**:
+   ```
+   bazel mobile-install //:oppia_dev_binary
+   ```
+This will build, install and launch the app on your device.
+
+**On SDK 30 and newer, run**:
+   ```
+   bazel build //:oppia_dev
+   ```
+followed by:
+   ```
+   adb install bazel-bin/oppia_dev_binary.apk  
+   ```
+* Starting from Sdk 30, incremental builds, like those executed using `bazel mobile-install`, are no longer permitted, necessitating the use of two separate commands.
+
+If everything is working, you should see output like the following:
+
+```
+Target //:oppia_dev_binary up-to-date:
+  bazel-bin/oppia_dev_binary_deploy.jar
+  bazel-bin/oppia_dev_binary_unsigned.apk
+  bazel-bin/oppia_dev_binary.apk
+INFO: Elapsed time: 37.155s, Critical Path: 17.24s
+INFO: 99 processes: 2 internal, 23 darwin-sandbox, 74 worker.
+INFO: Build completed successfully, 99 total actions
+Performing Streamed Install
+Success
+```
+
+Note also that the ``oppia_dev.aab`` under the ``bazel-bin`` directory of your local copy of Oppia Android should be a fully functioning development version of the app that can be installed using bundle-tool. However, it's recommended to deploy Oppia to an emulator or connected device using the `mobile-install` command.
+
+## Running Tests
+
+The bazel test command is used to build and run tests in a Bazel workspace. It ensures that the specified test targets are built and executed in a sandboxed environment for reproducibility.
+
+**Syntax**
+
+```shell
+bazel test //path/to:target
+```
+
+### How to Obtain a Test Target
+A test target in Bazel refers to a specific testable entity defined in a BUILD file. It represents a test rule, such as `java_test` or `android_test`, that Bazel can build and execute.
+
+To ensure you always use the correct test target, follow one of these steps:
+1. If the test file is open in Android Studio:
+   * Right-click to open the context menu and select **Copy BUILD target string** as shown.
+     
+     ![Screenshot 2025-03-18 at 22 30 22](https://github.com/user-attachments/assets/286ebcb6-4f4e-4055-b6f0-4c070b039375)
+   
+   * Paste the target to the bazel test command, e.g. `bazel test //domain/src/test/java/org/oppia/android/domain/onboarding:AppStartupStateControllerTest`
+
+2. If the test file is open in Android Studio, but **Copy BUILD target string** is not available in the context menu:
+Sometimes the **Copy BUILD target string** is not available in the context menu either due to sync issues or modularization issues. You can still copy the file path, and pass it to the test command.
+   * In the AS sidebar, right click on the file, and select `copy path/reference`.
+     or
+   * Right-click on the file tab and then click `copy path/reference`.
+   * Next, select `copy path from repository root`. 
+   * Paste the copied path to the bazel test command in the terminal and remove the `.kt` extension, e.g. `bazel test domain/src/test/java/org/oppia/android/domain/onboarding/AppStartupStateControllerTest`.
+
+With this syntax, Bazel implicitly converts the file path into a target if it matches a test rule in the BUILD file. If the file is not part of a test target in the BUILD file, this command may fail.
+**When to use this**: If you are unsure about the exact Bazel target and want a quick way to run a test.
+
+3. Querying for a target
+Using the explicit Bazel target (// syntax) is more reliable compared to the file path syntax above. However, in cases such as running the test outside android studio, you may not know the target. In this case, you can use Bazel's `query` command to retrieve the correct test target:
+   * Copy the relative path of the test file.
+   * Run the following command in your terminal to get the test’s Bazel target: `bazel query relative-path-of-test-file`
+   Example
+   
+   ```shell
+   bazel query domain/src/test/java/org/oppia/android/domain/onboarding/AppStartupStateControllerTest.kt
+   ```
+   * The output will be a Bazel target that starts with //. Copy the target and remove the .kt extension.
+   * Use this target in the bazel test command, e.g. `bazel test //domain/src/test/java/org/oppia/android/domain/onboarding:AppStartupStateControllerTest`.
+
+### Common Flags
path: wiki/Bazel-User-Guide.md
user: login: adhiamboperes
body: Added
created_at: 2025-03-19T15:06:55Z
author_association: CONTRIBUTOR
diff_hunk: @@ -0,0 +1,277 @@
+## Table of Contents
+
+- [Overview](#overview)
+- [Installation](#installation)
+  - [Building the app](#building-the-app)
+- [Running Tests](#running-tests)
+  - [How to Obtain a Test Target](#how-to-obtain-a-test-target)
+  - [Common Flags](#common-flags)
+  - [Running multiple test targets](#running-multiple-test-targets)
+- [Concepts and Terminology](#concepts-and-terminology)
+- [Syncing the Project](#Syncing-the-project)
+
+## Overview
+Bazel is an open-source build and test tool similar to Make, Maven, and Gradle. It uses a human-readable, high-level build language.
+
+## Installation
+
+Follow the instructions on the [installation page](https://github.com/oppia/oppia-android/wiki/Installing-Oppia-Android#install-bazel) to set up Bazel.
+
+### Building the app
+
+The [installation page](https://github.com/oppia/oppia-android/wiki/Installing-Oppia-Android#install-bazel) provides information on running the project in Android Studio.
+
+You can also run the app from the command line using the commands detailed below.
+
+Using the command line is helpful in instances when you need to build and run some targets outside of Android Studio.
+
+Run the following commands in your terminal. All Bazel commands must be run from the root of the `oppia-android` directory otherwise they will fail.
+
+Note that on the first run, these commands may take 10-20 minutes to complete depending on the performance of your machine. Subsequent runs will be much faster.
+
+**On SDK 29 and below, run**:
+   ```
+   bazel mobile-install //:oppia_dev_binary
+   ```
+This will build, install and launch the app on your device.
+
+**On SDK 30 and newer, run**:
+   ```
+   bazel build //:oppia_dev
+   ```
+followed by:
+   ```
+   adb install bazel-bin/oppia_dev_binary.apk  
+   ```
+* Starting from Sdk 30, incremental builds, like those executed using `bazel mobile-install`, are no longer permitted, necessitating the use of two separate commands.
+
+If everything is working, you should see output like the following:
+
+```
+Target //:oppia_dev_binary up-to-date:
+  bazel-bin/oppia_dev_binary_deploy.jar
+  bazel-bin/oppia_dev_binary_unsigned.apk
+  bazel-bin/oppia_dev_binary.apk
+INFO: Elapsed time: 37.155s, Critical Path: 17.24s
+INFO: 99 processes: 2 internal, 23 darwin-sandbox, 74 worker.
+INFO: Build completed successfully, 99 total actions
+Performing Streamed Install
+Success
+```
+
+Note also that the ``oppia_dev.aab`` under the ``bazel-bin`` directory of your local copy of Oppia Android should be a fully functioning development version of the app that can be installed using bundle-tool. However, it's recommended to deploy Oppia to an emulator or connected device using the `mobile-install` command.
+
+## Running Tests
+
+The bazel test command is used to build and run tests in a Bazel workspace. It ensures that the specified test targets are built and executed in a sandboxed environment for reproducibility.
+
+**Syntax**
+
+```shell
+bazel test //path/to:target
+```
+
+### How to Obtain a Test Target
+A test target in Bazel refers to a specific testable entity defined in a BUILD file. It represents a test rule, such as `java_test` or `android_test`, that Bazel can build and execute.
+
+To ensure you always use the correct test target, follow one of these steps:
+1. If the test file is open in Android Studio:
+   * Right-click to open the context menu and select **Copy BUILD target string** as shown.
+     
+     ![Screenshot 2025-03-18 at 22 30 22](https://github.com/user-attachments/assets/286ebcb6-4f4e-4055-b6f0-4c070b039375)
+   
+   * Paste the target to the bazel test command, e.g. `bazel test //domain/src/test/java/org/oppia/android/domain/onboarding:AppStartupStateControllerTest`
+
+2. If the test file is open in Android Studio, but **Copy BUILD target string** is not available in the context menu:
+Sometimes the **Copy BUILD target string** is not available in the context menu either due to sync issues or modularization issues. You can still copy the file path, and pass it to the test command.
+   * In the AS sidebar, right click on the file, and select `copy path/reference`.
+     or
+   * Right-click on the file tab and then click `copy path/reference`.
+   * Next, select `copy path from repository root`. 
+   * Paste the copied path to the bazel test command in the terminal and remove the `.kt` extension, e.g. `bazel test domain/src/test/java/org/oppia/android/domain/onboarding/AppStartupStateControllerTest`.
+
+With this syntax, Bazel implicitly converts the file path into a target if it matches a test rule in the BUILD file. If the file is not part of a test target in the BUILD file, this command may fail.
+**When to use this**: If you are unsure about the exact Bazel target and want a quick way to run a test.
+
+3. Querying for a target
+Using the explicit Bazel target (// syntax) is more reliable compared to the file path syntax above. However, in cases such as running the test outside android studio, you may not know the target. In this case, you can use Bazel's `query` command to retrieve the correct test target:
+   * Copy the relative path of the test file.
+   * Run the following command in your terminal to get the test’s Bazel target: `bazel query relative-path-of-test-file`
+   Example
+   
+   ```shell
+   bazel query domain/src/test/java/org/oppia/android/domain/onboarding/AppStartupStateControllerTest.kt
+   ```
+   * The output will be a Bazel target that starts with //. Copy the target and remove the .kt extension.
+   * Use this target in the bazel test command, e.g. `bazel test //domain/src/test/java/org/oppia/android/domain/onboarding:AppStartupStateControllerTest`.
+
+### Common Flags
+
+`--test_output=all` → Show full test output.
+`--cache_test_results=no` → Force re-running tests even if cached.
+`--test_filter=ClassName#methodName` → Run specific test cases.
+
+### Running multiple test targets
+To run all the test targets in the app module:
+
+```
+bazel test //app/...
+```
+
+To run all the test targets in the project (note that this would be extremely slow and is not recommended):
+
+```
+bazel test //...
+```
+
+## Concepts and Terminology
+**[Workspace](https://github.com/oppia/oppia-android/blob/develop/WORKSPACE)**
+
+A workspace is a directory where we specify the targeted SDK version, required dependencies, and corresponding Rules. The directory containing the WORKSPACE file is the root of the main repository, which in our case, is the `oppia-android` root directory.
+**[Packages](https://github.com/oppia/oppia-android/tree/develop/app)**
+
+A package is defined as a directory containing a file named BUILD or BUILD.bazel.
+
+**[Binary rules](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/BUILD.bazel#L3)**
+
+A rule specifies the relationship between inputs and outputs, and the steps to build the outputs.
+In Android, rules are defined using `android_binary`. Android rules for testing are `android_instrumentation_test` and `android_local_test`.
+
+**[BUILD files](https://github.com/oppia/oppia-android/blob/develop/app/BUILD.bazel)**
+
+Every package contains a BUILD file. This file is written in Starlark Language. In this Build file for module-level, we generally define `android_library`, `kt_android_library` to build our package files as per the requirement.
+
+**[Dependencies](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/BUILD.bazel#L16)**
+
+A target A depends upon a target B if B is needed by A at build. `A -> B`
+
+```
+deps = [ "//app",]
+```
+Here, `deps` is used to define the dependencies which is a type of dependencies called `deps dependencies` and it includes the files/directory/target which are dependent. From the above example the dependency is the `app` target which is defined in the [Build file of app package](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/app/BUILD.bazel#L616).
+
+Example of Dependencies
+1. [srcs dependencies](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/app/BUILD.bazel#L617)
+2. [deps dependencies](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/app/BUILD.bazel#L622)
+
+**[Loading an extension](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/app/BUILD.bazel#L13)**
+
+Bazel extensions are files ending in .bzl. Use the load statement to import a symbol from an extension.
+
+```
+load("@io_bazel_rules_kotlin//kotlin:android.bzl", "kt_android_library")
+```
+Here, we are loading `android.bzl` and we are going to use it with a symbol name `kt_android_library`.
+Arguments to the load function must be string literals. load statements must appear at top-level in the file.
+
+**[Visibility of a file target](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/app/BUILD.bazel#L621)**
+
+With the example from our codebase, target `app` whose visibility is public. 
+
+ - `visibility = ["//visibility:public"],` - Anyone can use this target.
+ - `"//visibility:private"` - Only targets in this package can use this target.
+
+**[Testing](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/app/BUILD.bazel#L719)**
path: wiki/Bazel-User-Guide.md
user: login: adhiamboperes
body: Done
created_at: 2025-03-19T15:11:36Z
author_association: CONTRIBUTOR
diff_hunk: @@ -0,0 +1,277 @@
+## Table of Contents
+
+- [Overview](#overview)
+- [Installation](#installation)
+  - [Building the app](#building-the-app)
+- [Running Tests](#running-tests)
+  - [How to Obtain a Test Target](#how-to-obtain-a-test-target)
+  - [Common Flags](#common-flags)
+  - [Running multiple test targets](#running-multiple-test-targets)
+- [Concepts and Terminology](#concepts-and-terminology)
+- [Syncing the Project](#Syncing-the-project)
+
+## Overview
+Bazel is an open-source build and test tool similar to Make, Maven, and Gradle. It uses a human-readable, high-level build language.
+
+## Installation
+
+Follow the instructions on the [installation page](https://github.com/oppia/oppia-android/wiki/Installing-Oppia-Android#install-bazel) to set up Bazel.
+
+### Building the app
+
+The [installation page](https://github.com/oppia/oppia-android/wiki/Installing-Oppia-Android#install-bazel) provides information on running the project in Android Studio.
+
+You can also run the app from the command line using the commands detailed below.
+
+Using the command line is helpful in instances when you need to build and run some targets outside of Android Studio.
+
+Run the following commands in your terminal. All Bazel commands must be run from the root of the `oppia-android` directory otherwise they will fail.
+
+Note that on the first run, these commands may take 10-20 minutes to complete depending on the performance of your machine. Subsequent runs will be much faster.
+
+**On SDK 29 and below, run**:
+   ```
+   bazel mobile-install //:oppia_dev_binary
+   ```
+This will build, install and launch the app on your device.
+
+**On SDK 30 and newer, run**:
+   ```
+   bazel build //:oppia_dev
+   ```
+followed by:
+   ```
+   adb install bazel-bin/oppia_dev_binary.apk  
+   ```
+* Starting from Sdk 30, incremental builds, like those executed using `bazel mobile-install`, are no longer permitted, necessitating the use of two separate commands.
+
+If everything is working, you should see output like the following:
+
+```
+Target //:oppia_dev_binary up-to-date:
+  bazel-bin/oppia_dev_binary_deploy.jar
+  bazel-bin/oppia_dev_binary_unsigned.apk
+  bazel-bin/oppia_dev_binary.apk
+INFO: Elapsed time: 37.155s, Critical Path: 17.24s
+INFO: 99 processes: 2 internal, 23 darwin-sandbox, 74 worker.
+INFO: Build completed successfully, 99 total actions
+Performing Streamed Install
+Success
+```
+
+Note also that the ``oppia_dev.aab`` under the ``bazel-bin`` directory of your local copy of Oppia Android should be a fully functioning development version of the app that can be installed using bundle-tool. However, it's recommended to deploy Oppia to an emulator or connected device using the `mobile-install` command.
+
+## Running Tests
+
+The bazel test command is used to build and run tests in a Bazel workspace. It ensures that the specified test targets are built and executed in a sandboxed environment for reproducibility.
+
+**Syntax**
+
+```shell
+bazel test //path/to:target
+```
+
+### How to Obtain a Test Target
+A test target in Bazel refers to a specific testable entity defined in a BUILD file. It represents a test rule, such as `java_test` or `android_test`, that Bazel can build and execute.
+
+To ensure you always use the correct test target, follow one of these steps:
+1. If the test file is open in Android Studio:
+   * Right-click to open the context menu and select **Copy BUILD target string** as shown.
+     
+     ![Screenshot 2025-03-18 at 22 30 22](https://github.com/user-attachments/assets/286ebcb6-4f4e-4055-b6f0-4c070b039375)
+   
+   * Paste the target to the bazel test command, e.g. `bazel test //domain/src/test/java/org/oppia/android/domain/onboarding:AppStartupStateControllerTest`
+
+2. If the test file is open in Android Studio, but **Copy BUILD target string** is not available in the context menu:
+Sometimes the **Copy BUILD target string** is not available in the context menu either due to sync issues or modularization issues. You can still copy the file path, and pass it to the test command.
+   * In the AS sidebar, right click on the file, and select `copy path/reference`.
+     or
+   * Right-click on the file tab and then click `copy path/reference`.
+   * Next, select `copy path from repository root`. 
+   * Paste the copied path to the bazel test command in the terminal and remove the `.kt` extension, e.g. `bazel test domain/src/test/java/org/oppia/android/domain/onboarding/AppStartupStateControllerTest`.
+
+With this syntax, Bazel implicitly converts the file path into a target if it matches a test rule in the BUILD file. If the file is not part of a test target in the BUILD file, this command may fail.
+**When to use this**: If you are unsure about the exact Bazel target and want a quick way to run a test.
+
+3. Querying for a target
+Using the explicit Bazel target (// syntax) is more reliable compared to the file path syntax above. However, in cases such as running the test outside android studio, you may not know the target. In this case, you can use Bazel's `query` command to retrieve the correct test target:
+   * Copy the relative path of the test file.
+   * Run the following command in your terminal to get the test’s Bazel target: `bazel query relative-path-of-test-file`
+   Example
+   
+   ```shell
+   bazel query domain/src/test/java/org/oppia/android/domain/onboarding/AppStartupStateControllerTest.kt
+   ```
+   * The output will be a Bazel target that starts with //. Copy the target and remove the .kt extension.
+   * Use this target in the bazel test command, e.g. `bazel test //domain/src/test/java/org/oppia/android/domain/onboarding:AppStartupStateControllerTest`.
+
+### Common Flags
+
+`--test_output=all` → Show full test output.
+`--cache_test_results=no` → Force re-running tests even if cached.
+`--test_filter=ClassName#methodName` → Run specific test cases.
+
+### Running multiple test targets
+To run all the test targets in the app module:
+
+```
+bazel test //app/...
+```
+
+To run all the test targets in the project (note that this would be extremely slow and is not recommended):
+
+```
+bazel test //...
+```
+
+## Concepts and Terminology
+**[Workspace](https://github.com/oppia/oppia-android/blob/develop/WORKSPACE)**
+
+A workspace is a directory where we specify the targeted SDK version, required dependencies, and corresponding Rules. The directory containing the WORKSPACE file is the root of the main repository, which in our case, is the `oppia-android` root directory.
+**[Packages](https://github.com/oppia/oppia-android/tree/develop/app)**
+
+A package is defined as a directory containing a file named BUILD or BUILD.bazel.
+
+**[Binary rules](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/BUILD.bazel#L3)**
+
+A rule specifies the relationship between inputs and outputs, and the steps to build the outputs.
+In Android, rules are defined using `android_binary`. Android rules for testing are `android_instrumentation_test` and `android_local_test`.
+
+**[BUILD files](https://github.com/oppia/oppia-android/blob/develop/app/BUILD.bazel)**
+
+Every package contains a BUILD file. This file is written in Starlark Language. In this Build file for module-level, we generally define `android_library`, `kt_android_library` to build our package files as per the requirement.
+
+**[Dependencies](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/BUILD.bazel#L16)**
+
+A target A depends upon a target B if B is needed by A at build. `A -> B`
+
+```
+deps = [ "//app",]
+```
+Here, `deps` is used to define the dependencies which is a type of dependencies called `deps dependencies` and it includes the files/directory/target which are dependent. From the above example the dependency is the `app` target which is defined in the [Build file of app package](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/app/BUILD.bazel#L616).
+
+Example of Dependencies
+1. [srcs dependencies](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/app/BUILD.bazel#L617)
+2. [deps dependencies](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/app/BUILD.bazel#L622)
+
+**[Loading an extension](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/app/BUILD.bazel#L13)**
+
+Bazel extensions are files ending in .bzl. Use the load statement to import a symbol from an extension.
+
+```
+load("@io_bazel_rules_kotlin//kotlin:android.bzl", "kt_android_library")
+```
+Here, we are loading `android.bzl` and we are going to use it with a symbol name `kt_android_library`.
+Arguments to the load function must be string literals. load statements must appear at top-level in the file.
+
+**[Visibility of a file target](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/app/BUILD.bazel#L621)**
+
+With the example from our codebase, target `app` whose visibility is public. 
+
+ - `visibility = ["//visibility:public"],` - Anyone can use this target.
+ - `"//visibility:private"` - Only targets in this package can use this target.
+
+**[Testing](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/app/BUILD.bazel#L719)**
+
+when we want to run test cases on Bazel build environment, a test target needs to be set up correctly:
+
+```bazel
+load("//:oppia_android_test.bzl", "oppia_android_test")
+
+oppia_android_test(
+    name = "MathExpressionInteractionsViewTest",
+    srcs = [
+        "MathExpressionInteractionsViewTest.kt",
+        "//app:data_binder_mapper_impl"
+    ],
+    custom_package = "org.oppia.android.app.test",
+    test_manifest = "//app:test_manifest",
+    enable_data_binding = True,
+    test_class = "org.oppia.android.app.customview.interaction.MathExpressionInteractionsViewTest",
+    deps = [
+      ...
+    ],
+)
+```
+
+The above assumes that the corresponding test requires resources. If it doesn't, the definition can be a bit simpler:
+
+```bazel
+load("//:oppia_android_test.bzl", "oppia_android_test")
+
+oppia_android_test(
+    name = "MathExpressionAccessibilityUtilTest",
+    srcs = ["MathExpressionAccessibilityUtilTest.kt"],
+    custom_package = "org.oppia.android.app.utility.math",
+    test_class = "org.oppia.android.app.utility.math.MathExpressionAccessibilityUtilTest",
+    test_manifest = "//app:test_manifest",
+    deps = [
+      ...
+    ],
path: wiki/Bazel-User-Guide.md
user: login: adhiamboperes
body: Done
created_at: 2025-03-19T15:14:31Z
author_association: CONTRIBUTOR
diff_hunk: @@ -0,0 +1,277 @@
+## Table of Contents
+
+- [Overview](#overview)
+- [Installation](#installation)
+  - [Building the app](#building-the-app)
+- [Running Tests](#running-tests)
+  - [How to Obtain a Test Target](#how-to-obtain-a-test-target)
+  - [Common Flags](#common-flags)
+  - [Running multiple test targets](#running-multiple-test-targets)
+- [Concepts and Terminology](#concepts-and-terminology)
+- [Syncing the Project](#Syncing-the-project)
+
+## Overview
+Bazel is an open-source build and test tool similar to Make, Maven, and Gradle. It uses a human-readable, high-level build language.
+
+## Installation
+
+Follow the instructions on the [installation page](https://github.com/oppia/oppia-android/wiki/Installing-Oppia-Android#install-bazel) to set up Bazel.
+
+### Building the app
+
+The [installation page](https://github.com/oppia/oppia-android/wiki/Installing-Oppia-Android#install-bazel) provides information on running the project in Android Studio.
+
+You can also run the app from the command line using the commands detailed below.
+
+Using the command line is helpful in instances when you need to build and run some targets outside of Android Studio.
+
+Run the following commands in your terminal. All Bazel commands must be run from the root of the `oppia-android` directory otherwise they will fail.
+
+Note that on the first run, these commands may take 10-20 minutes to complete depending on the performance of your machine. Subsequent runs will be much faster.
+
+**On SDK 29 and below, run**:
+   ```
+   bazel mobile-install //:oppia_dev_binary
+   ```
+This will build, install and launch the app on your device.
+
+**On SDK 30 and newer, run**:
+   ```
+   bazel build //:oppia_dev
+   ```
+followed by:
+   ```
+   adb install bazel-bin/oppia_dev_binary.apk  
+   ```
+* Starting from Sdk 30, incremental builds, like those executed using `bazel mobile-install`, are no longer permitted, necessitating the use of two separate commands.
path: wiki/Bazel-User-Guide.md
user: login: adhiamboperes
body: Fixed. This is the only occurance found.
created_at: 2025-03-19T15:14:55Z
author_association: CONTRIBUTOR
diff_hunk: @@ -5,32 +5,322 @@ This wiki page explains how to install Oppia Android on your local machine. If y
 ## Table of Contents
 
 - [Prepare developer environment](#prepare-developer-environment)
+- [install Bazel](#install-bazel)
+  - [Bazel Set up for Mac](#bazel-set-up-for-mac)
+  - [Bazel Set up for Linux](#bazel-set-up-for-linux)
+  - [Bazel Set up for Windows](#bazel-set-up-for-windows)
 - [Install oppia-android](#install-oppia-android)
-- [Run the app from Android Studio](#run-the-app-from-android-studio)
+- [Opening the Project in Android Studio](#opening-the-project-in-android-studio)
 - [Set up and Run tests](#set-up-and-run-tests)
-  - [Step-by-Step guidance for setting up and running app modules robolectric test](#step-by-step-guidance-for-setting-up-and-running-app-modules-robolectric-test)
-  - [For tests that are in non-app modules, such as **domain** or **utility**:](#for-tests-that-are-in-non-app-modules-such-as-domain-or-utility)
-
+  - [Running app module tests](#running-app-module-tests)
+  - [Running non-app module tests](#running-non-app-module-tests)
+- [Next Steps](#next-steps)
+- [Troubleshooting Installation](#troubleshooting-installation)
 
 ## Prepare developer environment
 
-1. Download/Install [Android Studio Bumblebee | Patch 3](https://developer.android.com/studio/archive).
+1. Download and install Android Studio **Giraffe** from [this location](https://developer.android.com/studio/archive).
+   **Note**: You may try newer or older versions of Android Studio, but we can't guarantee good support.
 
-   **Note**: We recommend installing **Android Studio Bumblebee | 2021.1.1 Patch 3** because newer versions of Android Studio[ do not support running tests where shared source sets are used](https://issuetracker.google.com/issues/232007221#comment18), a configuration we use at Oppia.
+2. Configure your Android Studio
+   - From your PC's application menu, open Android Studio. 
+   - On the welcome screen, find the "more options menu" and select **SDK Manager**
+     
+     <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/efcc4e6e-b6ba-44fc-9c96-aa381de83911" />
+    
+   - In the "SDK Platforms" tab (which is the default), select `API Level 30` and also `API Level 34`.
+   - Also, navigate to the "SDK Tools" tab, click the "Show Package Details" checkbox at the bottom right, then click on "Android SDK Build-Tools 34-rc1" and select 32.0.0 (this is needed for Bazel support).
 
-   **Direct download Url**: [Windows](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-windows.exe) | [Linux](https://redirector.gvt1.com/edgedl/android/studio/ide-zips/2021.1.1.23/android-studio-2021.1.1.23-linux.tar.gz) | [Intel Mac](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-mac.dmg) | [Apple Silicon Mac](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-mac_arm.dmg)
+   - Then, click "Apply" to download and install these two SDKs/Tools.
+     - On this screen, note the **Android SDK Location**, which is set as the ANDROID_HOME variable in  the Bazel setup step below.
path: wiki/Installing-Oppia-Android.md
user: login: adhiamboperes
body: Fixed.
created_at: 2025-03-19T15:17:17Z
author_association: CONTRIBUTOR
diff_hunk: @@ -0,0 +1,277 @@
+## Table of Contents
+
+- [Overview](#overview)
+- [Installation](#installation)
+  - [Building the app](#building-the-app)
+- [Running Tests](#running-tests)
+  - [How to Obtain a Test Target](#how-to-obtain-a-test-target)
+  - [Common Flags](#common-flags)
+  - [Running multiple test targets](#running-multiple-test-targets)
+- [Concepts and Terminology](#concepts-and-terminology)
+- [Syncing the Project](#Syncing-the-project)
+
+## Overview
+Bazel is an open-source build and test tool similar to Make, Maven, and Gradle. It uses a human-readable, high-level build language.
+
+## Installation
+
+Follow the instructions on the [installation page](https://github.com/oppia/oppia-android/wiki/Installing-Oppia-Android#install-bazel) to set up Bazel.
+
+### Building the app
+
+The [installation page](https://github.com/oppia/oppia-android/wiki/Installing-Oppia-Android#install-bazel) provides information on running the project in Android Studio.
+
+You can also run the app from the command line using the commands detailed below.
+
+Using the command line is helpful in instances when you need to build and run some targets outside of Android Studio.
+
+Run the following commands in your terminal. All Bazel commands must be run from the root of the `oppia-android` directory otherwise they will fail.
+
+Note that on the first run, these commands may take 10-20 minutes to complete depending on the performance of your machine. Subsequent runs will be much faster.
+
+**On SDK 29 and below, run**:
+   ```
+   bazel mobile-install //:oppia_dev_binary
+   ```
+This will build, install and launch the app on your device.
+
+**On SDK 30 and newer, run**:
+   ```
+   bazel build //:oppia_dev
+   ```
+followed by:
+   ```
+   adb install bazel-bin/oppia_dev_binary.apk  
+   ```
+* Starting from Sdk 30, incremental builds, like those executed using `bazel mobile-install`, are no longer permitted, necessitating the use of two separate commands.
+
+If everything is working, you should see output like the following:
+
+```
+Target //:oppia_dev_binary up-to-date:
+  bazel-bin/oppia_dev_binary_deploy.jar
+  bazel-bin/oppia_dev_binary_unsigned.apk
+  bazel-bin/oppia_dev_binary.apk
+INFO: Elapsed time: 37.155s, Critical Path: 17.24s
+INFO: 99 processes: 2 internal, 23 darwin-sandbox, 74 worker.
+INFO: Build completed successfully, 99 total actions
+Performing Streamed Install
+Success
+```
+
+Note also that the ``oppia_dev.aab`` under the ``bazel-bin`` directory of your local copy of Oppia Android should be a fully functioning development version of the app that can be installed using bundle-tool. However, it's recommended to deploy Oppia to an emulator or connected device using the `mobile-install` command.
+
+## Running Tests
+
+The bazel test command is used to build and run tests in a Bazel workspace. It ensures that the specified test targets are built and executed in a sandboxed environment for reproducibility.
+
+**Syntax**
+
+```shell
+bazel test //path/to:target
+```
+
+### How to Obtain a Test Target
+A test target in Bazel refers to a specific testable entity defined in a BUILD file. It represents a test rule, such as `java_test` or `android_test`, that Bazel can build and execute.
+
+To ensure you always use the correct test target, follow one of these steps:
+1. If the test file is open in Android Studio:
+   * Right-click to open the context menu and select **Copy BUILD target string** as shown.
+     
+     ![Screenshot 2025-03-18 at 22 30 22](https://github.com/user-attachments/assets/286ebcb6-4f4e-4055-b6f0-4c070b039375)
+   
+   * Paste the target to the bazel test command, e.g. `bazel test //domain/src/test/java/org/oppia/android/domain/onboarding:AppStartupStateControllerTest`
+
+2. If the test file is open in Android Studio, but **Copy BUILD target string** is not available in the context menu:
+Sometimes the **Copy BUILD target string** is not available in the context menu either due to sync issues or modularization issues. You can still copy the file path, and pass it to the test command.
+   * In the AS sidebar, right click on the file, and select `copy path/reference`.
+     or
+   * Right-click on the file tab and then click `copy path/reference`.
+   * Next, select `copy path from repository root`. 
+   * Paste the copied path to the bazel test command in the terminal and remove the `.kt` extension, e.g. `bazel test domain/src/test/java/org/oppia/android/domain/onboarding/AppStartupStateControllerTest`.
+
+With this syntax, Bazel implicitly converts the file path into a target if it matches a test rule in the BUILD file. If the file is not part of a test target in the BUILD file, this command may fail.
+**When to use this**: If you are unsure about the exact Bazel target and want a quick way to run a test.
+
+3. Querying for a target
+Using the explicit Bazel target (// syntax) is more reliable compared to the file path syntax above. However, in cases such as running the test outside android studio, you may not know the target. In this case, you can use Bazel's `query` command to retrieve the correct test target:
+   * Copy the relative path of the test file.
+   * Run the following command in your terminal to get the test’s Bazel target: `bazel query relative-path-of-test-file`
+   Example
+   
+   ```shell
+   bazel query domain/src/test/java/org/oppia/android/domain/onboarding/AppStartupStateControllerTest.kt
+   ```
+   * The output will be a Bazel target that starts with //. Copy the target and remove the .kt extension.
+   * Use this target in the bazel test command, e.g. `bazel test //domain/src/test/java/org/oppia/android/domain/onboarding:AppStartupStateControllerTest`.
+
+### Common Flags
+
+`--test_output=all` → Show full test output.
+`--cache_test_results=no` → Force re-running tests even if cached.
+`--test_filter=ClassName#methodName` → Run specific test cases.
+
+### Running multiple test targets
+To run all the test targets in the app module:
+
+```
+bazel test //app/...
+```
+
+To run all the test targets in the project (note that this would be extremely slow and is not recommended):
+
+```
+bazel test //...
+```
+
+## Concepts and Terminology
+**[Workspace](https://github.com/oppia/oppia-android/blob/develop/WORKSPACE)**
+
+A workspace is a directory where we specify the targeted SDK version, required dependencies, and corresponding Rules. The directory containing the WORKSPACE file is the root of the main repository, which in our case, is the `oppia-android` root directory.
+**[Packages](https://github.com/oppia/oppia-android/tree/develop/app)**
+
+A package is defined as a directory containing a file named BUILD or BUILD.bazel.
+
+**[Binary rules](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/BUILD.bazel#L3)**
+
+A rule specifies the relationship between inputs and outputs, and the steps to build the outputs.
+In Android, rules are defined using `android_binary`. Android rules for testing are `android_instrumentation_test` and `android_local_test`.
+
+**[BUILD files](https://github.com/oppia/oppia-android/blob/develop/app/BUILD.bazel)**
path: wiki/Bazel-User-Guide.md
user: login: adhiamboperes
body: Done
created_at: 2025-03-19T15:25:00Z
author_association: CONTRIBUTOR
diff_hunk: @@ -0,0 +1,277 @@
+## Table of Contents
+
+- [Overview](#overview)
+- [Installation](#installation)
+  - [Building the app](#building-the-app)
+- [Running Tests](#running-tests)
+  - [How to Obtain a Test Target](#how-to-obtain-a-test-target)
+  - [Common Flags](#common-flags)
+  - [Running multiple test targets](#running-multiple-test-targets)
+- [Concepts and Terminology](#concepts-and-terminology)
+- [Syncing the Project](#Syncing-the-project)
+
+## Overview
+Bazel is an open-source build and test tool similar to Make, Maven, and Gradle. It uses a human-readable, high-level build language.
+
+## Installation
+
+Follow the instructions on the [installation page](https://github.com/oppia/oppia-android/wiki/Installing-Oppia-Android#install-bazel) to set up Bazel.
+
+### Building the app
+
+The [installation page](https://github.com/oppia/oppia-android/wiki/Installing-Oppia-Android#install-bazel) provides information on running the project in Android Studio.
+
+You can also run the app from the command line using the commands detailed below.
+
+Using the command line is helpful in instances when you need to build and run some targets outside of Android Studio.
+
+Run the following commands in your terminal. All Bazel commands must be run from the root of the `oppia-android` directory otherwise they will fail.
+
+Note that on the first run, these commands may take 10-20 minutes to complete depending on the performance of your machine. Subsequent runs will be much faster.
+
+**On SDK 29 and below, run**:
+   ```
+   bazel mobile-install //:oppia_dev_binary
+   ```
+This will build, install and launch the app on your device.
+
+**On SDK 30 and newer, run**:
+   ```
+   bazel build //:oppia_dev
+   ```
+followed by:
+   ```
+   adb install bazel-bin/oppia_dev_binary.apk  
+   ```
+* Starting from Sdk 30, incremental builds, like those executed using `bazel mobile-install`, are no longer permitted, necessitating the use of two separate commands.
+
+If everything is working, you should see output like the following:
+
+```
+Target //:oppia_dev_binary up-to-date:
+  bazel-bin/oppia_dev_binary_deploy.jar
+  bazel-bin/oppia_dev_binary_unsigned.apk
+  bazel-bin/oppia_dev_binary.apk
+INFO: Elapsed time: 37.155s, Critical Path: 17.24s
+INFO: 99 processes: 2 internal, 23 darwin-sandbox, 74 worker.
+INFO: Build completed successfully, 99 total actions
+Performing Streamed Install
+Success
+```
+
+Note also that the ``oppia_dev.aab`` under the ``bazel-bin`` directory of your local copy of Oppia Android should be a fully functioning development version of the app that can be installed using bundle-tool. However, it's recommended to deploy Oppia to an emulator or connected device using the `mobile-install` command.
+
+## Running Tests
+
+The bazel test command is used to build and run tests in a Bazel workspace. It ensures that the specified test targets are built and executed in a sandboxed environment for reproducibility.
+
+**Syntax**
+
+```shell
+bazel test //path/to:target
+```
+
+### How to Obtain a Test Target
+A test target in Bazel refers to a specific testable entity defined in a BUILD file. It represents a test rule, such as `java_test` or `android_test`, that Bazel can build and execute.
+
+To ensure you always use the correct test target, follow one of these steps:
+1. If the test file is open in Android Studio:
+   * Right-click to open the context menu and select **Copy BUILD target string** as shown.
+     
+     ![Screenshot 2025-03-18 at 22 30 22](https://github.com/user-attachments/assets/286ebcb6-4f4e-4055-b6f0-4c070b039375)
+   
+   * Paste the target to the bazel test command, e.g. `bazel test //domain/src/test/java/org/oppia/android/domain/onboarding:AppStartupStateControllerTest`
+
+2. If the test file is open in Android Studio, but **Copy BUILD target string** is not available in the context menu:
+Sometimes the **Copy BUILD target string** is not available in the context menu either due to sync issues or modularization issues. You can still copy the file path, and pass it to the test command.
+   * In the AS sidebar, right click on the file, and select `copy path/reference`.
+     or
+   * Right-click on the file tab and then click `copy path/reference`.
+   * Next, select `copy path from repository root`. 
+   * Paste the copied path to the bazel test command in the terminal and remove the `.kt` extension, e.g. `bazel test domain/src/test/java/org/oppia/android/domain/onboarding/AppStartupStateControllerTest`.
+
+With this syntax, Bazel implicitly converts the file path into a target if it matches a test rule in the BUILD file. If the file is not part of a test target in the BUILD file, this command may fail.
+**When to use this**: If you are unsure about the exact Bazel target and want a quick way to run a test.
+
+3. Querying for a target
+Using the explicit Bazel target (// syntax) is more reliable compared to the file path syntax above. However, in cases such as running the test outside android studio, you may not know the target. In this case, you can use Bazel's `query` command to retrieve the correct test target:
+   * Copy the relative path of the test file.
+   * Run the following command in your terminal to get the test’s Bazel target: `bazel query relative-path-of-test-file`
+   Example
+   
+   ```shell
+   bazel query domain/src/test/java/org/oppia/android/domain/onboarding/AppStartupStateControllerTest.kt
+   ```
+   * The output will be a Bazel target that starts with //. Copy the target and remove the .kt extension.
+   * Use this target in the bazel test command, e.g. `bazel test //domain/src/test/java/org/oppia/android/domain/onboarding:AppStartupStateControllerTest`.
+
+### Common Flags
+
+`--test_output=all` → Show full test output.
+`--cache_test_results=no` → Force re-running tests even if cached.
+`--test_filter=ClassName#methodName` → Run specific test cases.
+
+### Running multiple test targets
path: wiki/Bazel-User-Guide.md
user: login: adhiamboperes
body: Added
created_at: 2025-03-19T15:27:59Z
author_association: CONTRIBUTOR
diff_hunk: @@ -365,60 +374,55 @@ Please follow these steps to set up Oppia Android on your local machine.
 
    <img width="760" alt="Image" src="https://github.com/user-attachments/assets/5a26210f-865d-4048-b5a5-73379984bfb5" />
 
-7. In the above file, modify it so that it looks like below(copy and paste):
-   
-   ```
-   directories:
-      # Add the directories you want added as source here
-      # By default, we've added your entire workspace ('.')
-      .
-      
-   # Automatically includes all relevant targets under the 'directories' above
-   derive_targets_from_directories: false
-   
-   targets:
-   # If source code isn't resolving, add additional targets that compile it here
-      //:oppia_dev_binary
-      //app
-      //app/src/main/...
-      //domain/...
-      //model/...
-      //testing/...
-      //utility/...
-      //data/...
-      //scripts/...
-      
-   additional_languages:
-      # Uncomment any additional languages you want supported
-      # c
-      # dart
-      # kotlin
-      java
-      kotlin
-
-   # Please uncomment an android-SDK platform. Available SDKs are:
-      # android_sdk_platform: android-28
-      android_sdk_platform: android-29
-      # android_sdk_platform: android-30
-      # android_sdk_platform: android-31
-      # android_sdk_platform: android-32
-      # android_sdk_platform: android-33
-      android_sdk_platform: android-34
-   
-   shard_sync: true
-   sync_flags:
-      --local_ram_resources=HOST_RAM*.5
-      --discard_analysis_cache
+7. In the above file, modify it so that it looks like below (copy and paste):
    
-   java_language_level: 11
-   ```
+```
+directories:
path: wiki/Installing-Oppia-Android.md
user: login: adhiamboperes
body: Done. Also modified the import instructions.
created_at: 2025-03-19T16:12:44Z
author_association: CONTRIBUTOR
diff_hunk: @@ -110,6 +110,7 @@ Using the explicit Bazel target (// syntax) is more reliable compared to the fil
 `--test_output=all` → Show full test output.
 `--cache_test_results=no` → Force re-running tests even if cached.
 `--test_filter=ClassName#methodName` → Run specific test cases.
+`--runs_per_test=1000` → Specifies number of times to run each test.
path: wiki/Bazel-User-Guide.md
user: login: BenHenning
body: ```suggestion
`--runs_per_test=100` → Specifies number of times to run each test. This can be useful for checking whether your test is flaky.
```

I know it's just an example, but I suspect the vast majority of people should probably not even default to 1000 runs for any test, and people have a tendency to copy examples as-is before fulling understanding the nuance behind the choices. :)

I'm also not particularly caring of '100' just that something smaller than '1000' should probably be used, and this seemed like a reasonable number. I originally thought '10' but in reality this should be used for flake detection, and anything less than '100' is not going to give good odds for infrequent flakes (and we do use '1000' for the tests that need to be the most stable, such as the data provider tests, but I tend to run those myself since I have access to some good parallelization for cases like this).
created_at: 2025-03-19T21:53:47Z
author_association: MEMBER
diff_hunk: @@ -366,61 +366,31 @@ Please follow these steps to set up Oppia Android on your local machine.
 
    <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/bfc91f6d-d809-418d-ab20-89d899f12f72" />
 
-5. On **next**, to Select Project View, **select Create from scratch**.
+5. On **next**, to Select Project View, select **Import project view file**.
 
-   <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/cdc110d6-2926-4f96-b7d8-117e2c716f76" />
+   <img width="991" alt="Screenshot 2025-03-19 at 18 44 41" src="https://github.com/user-attachments/assets/2679a750-414b-4680-8558-7f438e11f633" />
 
-6. A file similar to the one below will be generated:
+Click on the 3 dots to open the file picker. Scroll down and select `oppia-android.bazelproject`, then click **next**.
 
-   <img width="760" alt="Image" src="https://github.com/user-attachments/assets/5a26210f-865d-4048-b5a5-73379984bfb5" />
+   <img width="991" alt="Screenshot 2025-03-19 at 18 45 23" src="https://github.com/user-attachments/assets/31e0694c-a179-4adf-8d4d-28793c586ee5" />
 
-7. In the above file, modify it so that it looks like below (copy and paste):
-   
-```
-directories:
-  # Add the directories you want added as source here
-  # By default, we've added your entire workspace ('.')
-  .
-  
-# Automatically includes all relevant targets under the 'directories' above
-derive_targets_from_directories: false
-
-targets:
-# If source code isn't resolving, add additional targets that compile it here
-  //:oppia_dev_binary
-  //app/src/main/... 
-  //domain/src/main/... 
-  //testing/src/main/... 
-  //utility/src/main/... 
-  //data/src/main/... 
-  //model/...
-  
-additional_languages:
-  # Uncomment any additional languages you want supported
-  # c
-  # dart
-  # kotlin
-  java
-  kotlin
+6. The project view will be generated as follows. Click the **Create** button to complete the import.
 
-# Please uncomment an android-SDK platform. Available SDKs are:
-# android_sdk_platform: android-28
-# android_sdk_platform: android-29
-android_sdk_platform: android-30
-# android_sdk_platform: android-31
-# android_sdk_platform: android-32
-# android_sdk_platform: android-33
-android_sdk_platform: android-34
+   ![Screenshot 2025-03-19 at 18 47 57](https://github.com/user-attachments/assets/b7016ab8-9ae5-44e0-a624-c7cc8fc576da)
 
-shard_sync: true
+7. Immediately, the project will begin to synchronize, and will be ready once sync completes. Read more about syncing in the [Bazel User Guide](https://github.com/oppia/oppia-android/wiki/Bazel-User-Guide#Syncing-the-project).
 
-java_language_level: 11
-```
-   **Note**: Only enable Android-SDK platforms that you have installed per the [Prepare developer environment](#prepare-developer-environment) section above. Android-SDK platforms are useful for creating emulators to test your app with.
+   ![Screenshot 2025-03-19 at 18 49 59](https://github.com/user-attachments/assets/603d85d6-1336-4893-8153-eef8caef5e81)
 
-8. Click **Create**, and allow the project to synchronize. Read more about syncing at [Bazel User Guide](https://github.com/oppia/oppia-android/wiki/Bazel-User-Guide#Syncing-the-project).
+**Note**: Unlike Gradle, Bazel does not support the "**Android**" project view. To see all project directories, switch to the "**Project**" view instead.
+
+In the `.aswb` directory, you will find the generated `.bazelproject` file. It should contain:
+
+```shell
+import oppia-android.bazelproject
+```
path: wiki/Installing-Oppia-Android.md
user: login: BenHenning
body: Ooh, so importing a project view actually just generates the 'import' statement on its own? I want to double check this before approving since I expected that it would copy it.
created_at: 2025-03-19T21:57:53Z
author_association: MEMBER
diff_hunk: @@ -366,61 +366,31 @@ Please follow these steps to set up Oppia Android on your local machine.
 
    <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/bfc91f6d-d809-418d-ab20-89d899f12f72" />
 
-5. On **next**, to Select Project View, **select Create from scratch**.
+5. On **next**, to Select Project View, select **Import project view file**.
 
-   <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/cdc110d6-2926-4f96-b7d8-117e2c716f76" />
+   <img width="991" alt="Screenshot 2025-03-19 at 18 44 41" src="https://github.com/user-attachments/assets/2679a750-414b-4680-8558-7f438e11f633" />
 
-6. A file similar to the one below will be generated:
+Click on the 3 dots to open the file picker. Scroll down and select `oppia-android.bazelproject`, then click **next**.
 
-   <img width="760" alt="Image" src="https://github.com/user-attachments/assets/5a26210f-865d-4048-b5a5-73379984bfb5" />
+   <img width="991" alt="Screenshot 2025-03-19 at 18 45 23" src="https://github.com/user-attachments/assets/31e0694c-a179-4adf-8d4d-28793c586ee5" />
 
-7. In the above file, modify it so that it looks like below (copy and paste):
-   
-```
-directories:
-  # Add the directories you want added as source here
-  # By default, we've added your entire workspace ('.')
-  .
-  
-# Automatically includes all relevant targets under the 'directories' above
-derive_targets_from_directories: false
-
-targets:
-# If source code isn't resolving, add additional targets that compile it here
-  //:oppia_dev_binary
-  //app/src/main/... 
-  //domain/src/main/... 
-  //testing/src/main/... 
-  //utility/src/main/... 
-  //data/src/main/... 
-  //model/...
-  
-additional_languages:
-  # Uncomment any additional languages you want supported
-  # c
-  # dart
-  # kotlin
-  java
-  kotlin
+6. The project view will be generated as follows. Click the **Create** button to complete the import.
 
-# Please uncomment an android-SDK platform. Available SDKs are:
-# android_sdk_platform: android-28
-# android_sdk_platform: android-29
-android_sdk_platform: android-30
-# android_sdk_platform: android-31
-# android_sdk_platform: android-32
-# android_sdk_platform: android-33
-android_sdk_platform: android-34
+   ![Screenshot 2025-03-19 at 18 47 57](https://github.com/user-attachments/assets/b7016ab8-9ae5-44e0-a624-c7cc8fc576da)
 
-shard_sync: true
+7. Immediately, the project will begin to synchronize, and will be ready once sync completes. Read more about syncing in the [Bazel User Guide](https://github.com/oppia/oppia-android/wiki/Bazel-User-Guide#Syncing-the-project).
 
-java_language_level: 11
-```
-   **Note**: Only enable Android-SDK platforms that you have installed per the [Prepare developer environment](#prepare-developer-environment) section above. Android-SDK platforms are useful for creating emulators to test your app with.
+   ![Screenshot 2025-03-19 at 18 49 59](https://github.com/user-attachments/assets/603d85d6-1336-4893-8153-eef8caef5e81)
 
-8. Click **Create**, and allow the project to synchronize. Read more about syncing at [Bazel User Guide](https://github.com/oppia/oppia-android/wiki/Bazel-User-Guide#Syncing-the-project).
+**Note**: Unlike Gradle, Bazel does not support the "**Android**" project view. To see all project directories, switch to the "**Project**" view instead.
+
+In the `.aswb` directory, you will find the generated `.bazelproject` file. It should contain:
+
+```shell
+import oppia-android.bazelproject
+```
path: wiki/Installing-Oppia-Android.md
user: login: adhiamboperes
body: I tested the import, and this was the outcome.
created_at: 2025-03-19T22:20:59Z
author_association: CONTRIBUTOR
diff_hunk: @@ -110,6 +110,7 @@ Using the explicit Bazel target (// syntax) is more reliable compared to the fil
 `--test_output=all` → Show full test output.
 `--cache_test_results=no` → Force re-running tests even if cached.
 `--test_filter=ClassName#methodName` → Run specific test cases.
+`--runs_per_test=1000` → Specifies number of times to run each test.
path: wiki/Bazel-User-Guide.md
user: login: adhiamboperes
body: Done
created_at: 2025-03-20T22:42:41Z
author_association: CONTRIBUTOR
diff_hunk: @@ -0,0 +1,284 @@
+## Table of Contents
+
+- [Overview](#overview)
+- [Installation](#installation)
+  - [Building the app](#building-the-app)
+- [Running Tests](#running-tests)
+  - [How to Obtain a Test Target](#how-to-obtain-a-test-target)
+  - [Common Flags](#common-flags)
+  - [Running multiple test targets](#running-multiple-test-targets)
+- [Concepts and Terminology](#concepts-and-terminology)
+- [Syncing the Project](#syncing-the-project)
+
+## Overview
+Bazel is an open-source build and test tool similar to Make, Maven, and Gradle. It uses a human-readable, high-level build language.
+
+## Installation
+
+Follow the instructions on the [installation page](https://github.com/oppia/oppia-android/wiki/Installing-Oppia-Android#install-bazel) to set up Bazel.
+
+### Building the app
+
+The [installation page](https://github.com/oppia/oppia-android/wiki/Installing-Oppia-Android#install-bazel) provides information on running the project in Android Studio.
+
+You can also run the app from the command line using the commands detailed below.
+
+Using the command line is helpful in instances when you need to build and run some targets outside of Android Studio.
+
+Run the following commands in your terminal. All Bazel commands must be run from the root of the `oppia-android` directory otherwise they will fail.
+
+Note that on the first run, these commands may take 10-20 minutes to complete depending on the performance of your machine. Subsequent runs will be much faster.
+
+**On SDK 29 and below, run**:
+   ```
+   bazel mobile-install //:oppia_dev_binary
+   ```
+This will build, install and launch the app on your device.
+
+**On SDK 30 and newer, run**:
+   ```
+   bazel build //:oppia_dev
+   ```
+followed by:
+   ```
+   adb install bazel-bin/oppia_dev_binary.apk  
+   ```
+* Starting from SDK 30, incremental builds, like those executed using `bazel mobile-install`, are no longer permitted, necessitating the use of two separate commands.
+
+If everything is working, you should see output like the following:
+
+```
+Target //:oppia_dev_binary up-to-date:
+  bazel-bin/oppia_dev_binary_deploy.jar
+  bazel-bin/oppia_dev_binary_unsigned.apk
+  bazel-bin/oppia_dev_binary.apk
+INFO: Elapsed time: 37.155s, Critical Path: 17.24s
+INFO: 99 processes: 2 internal, 23 darwin-sandbox, 74 worker.
+INFO: Build completed successfully, 99 total actions
+Performing Streamed Install
+Success
+```
+
+Note also that the ``oppia_dev.aab`` under the ``bazel-bin`` directory of your local copy of Oppia Android should be a fully functioning development version of the app that can be installed using bundle-tool. However, it's recommended to deploy Oppia to an emulator or connected device using the `mobile-install` command.
+
+## Running Tests
+
+The bazel test command is used to build and run tests in a Bazel workspace. It ensures that the specified test targets are built and executed in a sandboxed environment for reproducibility.
+
+**Syntax**
+
+```shell
+bazel test //path/to:target
+```
+
+### How to Obtain a Test Target
+A test target in Bazel refers to a specific testable entity defined in a BUILD file. It represents a test rule, such as `java_test` or `android_test`, that Bazel can build and execute.
+
+To ensure you always use the correct test target, follow one of these steps:
+1. If the test file is open in Android Studio:
+   * Right-click to open the context menu and select **Copy BUILD target string** as shown.
+     
+     ![Screenshot 2025-03-18 at 22 30 22](https://github.com/user-attachments/assets/286ebcb6-4f4e-4055-b6f0-4c070b039375)
+   
+   * Paste the target to the bazel test command, e.g. `bazel test //domain/src/test/java/org/oppia/android/domain/onboarding:AppStartupStateControllerTest`
+
+2. If the test file is open in Android Studio, but **Copy BUILD target string** is not available in the context menu:
+Sometimes the **Copy BUILD target string** is not available in the context menu either due to sync issues or modularization issues. You can still copy the file path, and pass it to the test command.
+   * In the AS sidebar, right click on the file, and select `copy path/reference`.
+     or
+   * Right-click on the file tab and then click `copy path/reference`.
+   * Next, select `copy path from repository root`. 
+   * Paste the copied path to the bazel test command in the terminal and remove the `.kt` extension, e.g. `bazel test domain/src/test/java/org/oppia/android/domain/onboarding/AppStartupStateControllerTest`.
+
+With this syntax, Bazel implicitly converts the file path into a target if it matches a test rule in the BUILD file. If the file is not part of a test target in the BUILD file, this command may fail.
+**When to use this**: If you are unsure about the exact Bazel target and want a quick way to run a test.
+
+3. Querying for a target
+Using the explicit Bazel target (// syntax) is more reliable compared to the file path syntax above. However, in cases such as running the test outside android studio, you may not know the target. In this case, you can use Bazel's `query` command to retrieve the correct test target:
+   * Copy the relative path of the test file.
+   * Run the following command in your terminal to get the test’s Bazel target: `bazel query relative-path-of-test-file`
+   Example
+   
+   ```shell
+   bazel query domain/src/test/java/org/oppia/android/domain/onboarding/AppStartupStateControllerTest.kt
+   ```
+   * The output will be a Bazel target that starts with //. Copy the target and remove the .kt extension.
+   * Use this target in the bazel test command, e.g. `bazel test //domain/src/test/java/org/oppia/android/domain/onboarding:AppStartupStateControllerTest`.
+
+### Common Flags
+
+`--test_output=all` → Show full test output.
+`--cache_test_results=no` → Force re-running tests even if cached.
+`--test_filter=ClassName#methodName` → Run specific test cases.
+`--runs_per_test=100` → Specifies number of times to run each test.
+
+### Running multiple test targets
+To run all the test targets in the app module:
+
+```
+bazel test //app/...
+```
+
+To run all the test targets in the project (note that this would be extremely slow and is not recommended):
+
+```
+bazel test //...
+```
+
+To run multiple test targets at once:
+
+```
+bazel test -- //path/to/target/FirstTest //path/to/target/SecondTest
+```
+
+## Concepts and Terminology
+**[Workspace](https://github.com/oppia/oppia-android/blob/7344270032ac242b1b8987f1b51c8b5aa4f14ce3/WORKSPACE#L2)**
+
+A workspace is a directory where we specify the targeted SDK version, required dependencies, and corresponding Rules. The directory containing the WORKSPACE file is the root of the main repository, which in our case, is the `oppia-android` root directory.
+**[Packages](https://github.com/oppia/oppia-android/tree/develop/app)**
+
+A package is defined as a directory containing a file named BUILD or BUILD.bazel.
+
+**[Binary rules](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/BUILD.bazel#L3)**
+
+A rule specifies the relationship between inputs and outputs, and the steps to build the outputs.
+In Android, rules are defined using `android_binary`. Android rules for testing are `android_instrumentation_test` and `android_local_test`.
+
+**[BUILD files](https://github.com/oppia/oppia-android/blob/7344270032ac242b1b8987f1b51c8b5aa4f14ce3/app/BUILD.bazel#L3)**
+
+Every package contains a BUILD file. This file is written in Starlark Language. In this Build file for module-level, we generally define `android_library`, `kt_android_library` to build our package files as per the requirement.
+
+**[Dependencies](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/BUILD.bazel#L16)**
+
+A target A depends upon a target B if B is needed by A at build. `A -> B`
+
+```
+deps = [ "//app",]
+```
+Here, `deps` is used to define the dependencies which is a type of dependencies called `deps dependencies` and it includes the files/directory/target which are dependent. From the above example the dependency is the `app` target which is defined in the [Build file of app package](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/app/BUILD.bazel#L616).
path: wiki/Bazel-User-Guide.md
user: login: subhajitxyz
body: Missing a comma.
```suggestion
Here, `deps` is used to define the dependencies which is a type of dependencies called `deps dependencies` and it includes the files/directory/target which are dependent. From the above example, the dependency is the `app` target which is defined in the [Build file of app package](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/app/BUILD.bazel#L616).
```
created_at: 2025-03-26T13:25:49Z
author_association: COLLABORATOR
diff_hunk: @@ -0,0 +1,284 @@
+## Table of Contents
+
+- [Overview](#overview)
+- [Installation](#installation)
+  - [Building the app](#building-the-app)
+- [Running Tests](#running-tests)
+  - [How to Obtain a Test Target](#how-to-obtain-a-test-target)
+  - [Common Flags](#common-flags)
+  - [Running multiple test targets](#running-multiple-test-targets)
+- [Concepts and Terminology](#concepts-and-terminology)
+- [Syncing the Project](#syncing-the-project)
+
+## Overview
+Bazel is an open-source build and test tool similar to Make, Maven, and Gradle. It uses a human-readable, high-level build language.
+
+## Installation
+
+Follow the instructions on the [installation page](https://github.com/oppia/oppia-android/wiki/Installing-Oppia-Android#install-bazel) to set up Bazel.
+
+### Building the app
+
+The [installation page](https://github.com/oppia/oppia-android/wiki/Installing-Oppia-Android#install-bazel) provides information on running the project in Android Studio.
+
+You can also run the app from the command line using the commands detailed below.
+
+Using the command line is helpful in instances when you need to build and run some targets outside of Android Studio.
+
+Run the following commands in your terminal. All Bazel commands must be run from the root of the `oppia-android` directory otherwise they will fail.
+
+Note that on the first run, these commands may take 10-20 minutes to complete depending on the performance of your machine. Subsequent runs will be much faster.
+
+**On SDK 29 and below, run**:
+   ```
+   bazel mobile-install //:oppia_dev_binary
+   ```
+This will build, install and launch the app on your device.
+
+**On SDK 30 and newer, run**:
+   ```
+   bazel build //:oppia_dev
+   ```
+followed by:
+   ```
+   adb install bazel-bin/oppia_dev_binary.apk  
+   ```
+* Starting from SDK 30, incremental builds, like those executed using `bazel mobile-install`, are no longer permitted, necessitating the use of two separate commands.
+
+If everything is working, you should see output like the following:
+
+```
+Target //:oppia_dev_binary up-to-date:
+  bazel-bin/oppia_dev_binary_deploy.jar
+  bazel-bin/oppia_dev_binary_unsigned.apk
+  bazel-bin/oppia_dev_binary.apk
+INFO: Elapsed time: 37.155s, Critical Path: 17.24s
+INFO: 99 processes: 2 internal, 23 darwin-sandbox, 74 worker.
+INFO: Build completed successfully, 99 total actions
+Performing Streamed Install
+Success
+```
+
+Note also that the ``oppia_dev.aab`` under the ``bazel-bin`` directory of your local copy of Oppia Android should be a fully functioning development version of the app that can be installed using bundle-tool. However, it's recommended to deploy Oppia to an emulator or connected device using the `mobile-install` command.
+
+## Running Tests
+
+The bazel test command is used to build and run tests in a Bazel workspace. It ensures that the specified test targets are built and executed in a sandboxed environment for reproducibility.
+
+**Syntax**
+
+```shell
+bazel test //path/to:target
+```
+
+### How to Obtain a Test Target
+A test target in Bazel refers to a specific testable entity defined in a BUILD file. It represents a test rule, such as `java_test` or `android_test`, that Bazel can build and execute.
+
+To ensure you always use the correct test target, follow one of these steps:
+1. If the test file is open in Android Studio:
+   * Right-click to open the context menu and select **Copy BUILD target string** as shown.
+     
+     ![Screenshot 2025-03-18 at 22 30 22](https://github.com/user-attachments/assets/286ebcb6-4f4e-4055-b6f0-4c070b039375)
+   
+   * Paste the target to the bazel test command, e.g. `bazel test //domain/src/test/java/org/oppia/android/domain/onboarding:AppStartupStateControllerTest`
+
+2. If the test file is open in Android Studio, but **Copy BUILD target string** is not available in the context menu:
+Sometimes the **Copy BUILD target string** is not available in the context menu either due to sync issues or modularization issues. You can still copy the file path, and pass it to the test command.
+   * In the AS sidebar, right click on the file, and select `copy path/reference`.
+     or
+   * Right-click on the file tab and then click `copy path/reference`.
+   * Next, select `copy path from repository root`. 
+   * Paste the copied path to the bazel test command in the terminal and remove the `.kt` extension, e.g. `bazel test domain/src/test/java/org/oppia/android/domain/onboarding/AppStartupStateControllerTest`.
+
+With this syntax, Bazel implicitly converts the file path into a target if it matches a test rule in the BUILD file. If the file is not part of a test target in the BUILD file, this command may fail.
+**When to use this**: If you are unsure about the exact Bazel target and want a quick way to run a test.
+
+3. Querying for a target
+Using the explicit Bazel target (// syntax) is more reliable compared to the file path syntax above. However, in cases such as running the test outside android studio, you may not know the target. In this case, you can use Bazel's `query` command to retrieve the correct test target:
+   * Copy the relative path of the test file.
+   * Run the following command in your terminal to get the test’s Bazel target: `bazel query relative-path-of-test-file`
+   Example
+   
+   ```shell
+   bazel query domain/src/test/java/org/oppia/android/domain/onboarding/AppStartupStateControllerTest.kt
+   ```
+   * The output will be a Bazel target that starts with //. Copy the target and remove the .kt extension.
+   * Use this target in the bazel test command, e.g. `bazel test //domain/src/test/java/org/oppia/android/domain/onboarding:AppStartupStateControllerTest`.
+
+### Common Flags
+
+`--test_output=all` → Show full test output.
+`--cache_test_results=no` → Force re-running tests even if cached.
+`--test_filter=ClassName#methodName` → Run specific test cases.
+`--runs_per_test=100` → Specifies number of times to run each test.
+
+### Running multiple test targets
+To run all the test targets in the app module:
+
+```
+bazel test //app/...
+```
+
+To run all the test targets in the project (note that this would be extremely slow and is not recommended):
+
+```
+bazel test //...
+```
+
+To run multiple test targets at once:
+
+```
+bazel test -- //path/to/target/FirstTest //path/to/target/SecondTest
+```
+
+## Concepts and Terminology
+**[Workspace](https://github.com/oppia/oppia-android/blob/7344270032ac242b1b8987f1b51c8b5aa4f14ce3/WORKSPACE#L2)**
+
+A workspace is a directory where we specify the targeted SDK version, required dependencies, and corresponding Rules. The directory containing the WORKSPACE file is the root of the main repository, which in our case, is the `oppia-android` root directory.
+**[Packages](https://github.com/oppia/oppia-android/tree/develop/app)**
+
+A package is defined as a directory containing a file named BUILD or BUILD.bazel.
+
+**[Binary rules](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/BUILD.bazel#L3)**
+
+A rule specifies the relationship between inputs and outputs, and the steps to build the outputs.
+In Android, rules are defined using `android_binary`. Android rules for testing are `android_instrumentation_test` and `android_local_test`.
+
+**[BUILD files](https://github.com/oppia/oppia-android/blob/7344270032ac242b1b8987f1b51c8b5aa4f14ce3/app/BUILD.bazel#L3)**
+
+Every package contains a BUILD file. This file is written in Starlark Language. In this Build file for module-level, we generally define `android_library`, `kt_android_library` to build our package files as per the requirement.
+
+**[Dependencies](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/BUILD.bazel#L16)**
+
+A target A depends upon a target B if B is needed by A at build. `A -> B`
+
+```
+deps = [ "//app",]
+```
+Here, `deps` is used to define the dependencies which is a type of dependencies called `deps dependencies` and it includes the files/directory/target which are dependent. From the above example the dependency is the `app` target which is defined in the [Build file of app package](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/app/BUILD.bazel#L616).
+
+Example of Dependencies
+1. [srcs dependencies](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/app/BUILD.bazel#L617)
+2. [deps dependencies](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/app/BUILD.bazel#L622)
+
+**[Loading an extension](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/app/BUILD.bazel#L13)**
+
+Bazel extensions are files ending in .bzl. Use the load statement to import a symbol from an extension.
+
+```
+load("@io_bazel_rules_kotlin//kotlin:android.bzl", "kt_android_library")
+```
+Here, we are loading `android.bzl` and we are going to use it with a symbol name `kt_android_library`.
+Arguments to the load function must be string literals. load statements must appear at top-level in the file.
+
+**[Visibility of a file target](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/app/BUILD.bazel#L621)**
+
+With the example from our codebase, target `app` whose visibility is public. 
+
+ - `visibility = ["//visibility:public"],` - Anyone can use this target.
+ - `"//visibility:private"` - Only targets in this package can use this target.
+
+**[Testing](https://github.com/oppia/oppia-android/blob/7344270032ac242b1b8987f1b51c8b5aa4f14ce3/app/src/sharedTest/java/org/oppia/android/app/player/exploration/BUILD.bazel#L7)**
+
+when we want to run test cases on Bazel build environment, a test target needs to be set up correctly:
path: wiki/Bazel-User-Guide.md
user: login: subhajitxyz
body: Sentence should start with capital letter.
```suggestion
When we want to run test cases on Bazel build environment, a test target needs to be set up correctly:
```
created_at: 2025-03-26T13:29:34Z
author_association: COLLABORATOR
diff_hunk: @@ -0,0 +1,284 @@
+## Table of Contents
+
+- [Overview](#overview)
+- [Installation](#installation)
+  - [Building the app](#building-the-app)
+- [Running Tests](#running-tests)
+  - [How to Obtain a Test Target](#how-to-obtain-a-test-target)
+  - [Common Flags](#common-flags)
+  - [Running multiple test targets](#running-multiple-test-targets)
+- [Concepts and Terminology](#concepts-and-terminology)
+- [Syncing the Project](#syncing-the-project)
+
+## Overview
+Bazel is an open-source build and test tool similar to Make, Maven, and Gradle. It uses a human-readable, high-level build language.
+
+## Installation
+
+Follow the instructions on the [installation page](https://github.com/oppia/oppia-android/wiki/Installing-Oppia-Android#install-bazel) to set up Bazel.
+
+### Building the app
+
+The [installation page](https://github.com/oppia/oppia-android/wiki/Installing-Oppia-Android#install-bazel) provides information on running the project in Android Studio.
+
+You can also run the app from the command line using the commands detailed below.
+
+Using the command line is helpful in instances when you need to build and run some targets outside of Android Studio.
+
+Run the following commands in your terminal. All Bazel commands must be run from the root of the `oppia-android` directory otherwise they will fail.
+
+Note that on the first run, these commands may take 10-20 minutes to complete depending on the performance of your machine. Subsequent runs will be much faster.
+
+**On SDK 29 and below, run**:
+   ```
+   bazel mobile-install //:oppia_dev_binary
+   ```
+This will build, install and launch the app on your device.
+
+**On SDK 30 and newer, run**:
+   ```
+   bazel build //:oppia_dev
+   ```
+followed by:
+   ```
+   adb install bazel-bin/oppia_dev_binary.apk  
+   ```
+* Starting from SDK 30, incremental builds, like those executed using `bazel mobile-install`, are no longer permitted, necessitating the use of two separate commands.
+
+If everything is working, you should see output like the following:
+
+```
+Target //:oppia_dev_binary up-to-date:
+  bazel-bin/oppia_dev_binary_deploy.jar
+  bazel-bin/oppia_dev_binary_unsigned.apk
+  bazel-bin/oppia_dev_binary.apk
+INFO: Elapsed time: 37.155s, Critical Path: 17.24s
+INFO: 99 processes: 2 internal, 23 darwin-sandbox, 74 worker.
+INFO: Build completed successfully, 99 total actions
+Performing Streamed Install
+Success
+```
+
+Note also that the ``oppia_dev.aab`` under the ``bazel-bin`` directory of your local copy of Oppia Android should be a fully functioning development version of the app that can be installed using bundle-tool. However, it's recommended to deploy Oppia to an emulator or connected device using the `mobile-install` command.
+
+## Running Tests
+
+The bazel test command is used to build and run tests in a Bazel workspace. It ensures that the specified test targets are built and executed in a sandboxed environment for reproducibility.
+
+**Syntax**
+
+```shell
+bazel test //path/to:target
+```
+
+### How to Obtain a Test Target
+A test target in Bazel refers to a specific testable entity defined in a BUILD file. It represents a test rule, such as `java_test` or `android_test`, that Bazel can build and execute.
+
+To ensure you always use the correct test target, follow one of these steps:
+1. If the test file is open in Android Studio:
+   * Right-click to open the context menu and select **Copy BUILD target string** as shown.
+     
+     ![Screenshot 2025-03-18 at 22 30 22](https://github.com/user-attachments/assets/286ebcb6-4f4e-4055-b6f0-4c070b039375)
+   
+   * Paste the target to the bazel test command, e.g. `bazel test //domain/src/test/java/org/oppia/android/domain/onboarding:AppStartupStateControllerTest`
+
+2. If the test file is open in Android Studio, but **Copy BUILD target string** is not available in the context menu:
+Sometimes the **Copy BUILD target string** is not available in the context menu either due to sync issues or modularization issues. You can still copy the file path, and pass it to the test command.
+   * In the AS sidebar, right click on the file, and select `copy path/reference`.
+     or
+   * Right-click on the file tab and then click `copy path/reference`.
+   * Next, select `copy path from repository root`. 
+   * Paste the copied path to the bazel test command in the terminal and remove the `.kt` extension, e.g. `bazel test domain/src/test/java/org/oppia/android/domain/onboarding/AppStartupStateControllerTest`.
+
+With this syntax, Bazel implicitly converts the file path into a target if it matches a test rule in the BUILD file. If the file is not part of a test target in the BUILD file, this command may fail.
+**When to use this**: If you are unsure about the exact Bazel target and want a quick way to run a test.
+
+3. Querying for a target
+Using the explicit Bazel target (// syntax) is more reliable compared to the file path syntax above. However, in cases such as running the test outside android studio, you may not know the target. In this case, you can use Bazel's `query` command to retrieve the correct test target:
+   * Copy the relative path of the test file.
+   * Run the following command in your terminal to get the test’s Bazel target: `bazel query relative-path-of-test-file`
+   Example
+   
+   ```shell
+   bazel query domain/src/test/java/org/oppia/android/domain/onboarding/AppStartupStateControllerTest.kt
+   ```
+   * The output will be a Bazel target that starts with //. Copy the target and remove the .kt extension.
+   * Use this target in the bazel test command, e.g. `bazel test //domain/src/test/java/org/oppia/android/domain/onboarding:AppStartupStateControllerTest`.
+
+### Common Flags
+
+`--test_output=all` → Show full test output.
+`--cache_test_results=no` → Force re-running tests even if cached.
+`--test_filter=ClassName#methodName` → Run specific test cases.
+`--runs_per_test=100` → Specifies number of times to run each test.
+
+### Running multiple test targets
+To run all the test targets in the app module:
+
+```
+bazel test //app/...
+```
+
+To run all the test targets in the project (note that this would be extremely slow and is not recommended):
+
+```
+bazel test //...
+```
+
+To run multiple test targets at once:
+
+```
+bazel test -- //path/to/target/FirstTest //path/to/target/SecondTest
+```
+
+## Concepts and Terminology
+**[Workspace](https://github.com/oppia/oppia-android/blob/7344270032ac242b1b8987f1b51c8b5aa4f14ce3/WORKSPACE#L2)**
+
+A workspace is a directory where we specify the targeted SDK version, required dependencies, and corresponding Rules. The directory containing the WORKSPACE file is the root of the main repository, which in our case, is the `oppia-android` root directory.
+**[Packages](https://github.com/oppia/oppia-android/tree/develop/app)**
+
+A package is defined as a directory containing a file named BUILD or BUILD.bazel.
+
+**[Binary rules](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/BUILD.bazel#L3)**
+
+A rule specifies the relationship between inputs and outputs, and the steps to build the outputs.
+In Android, rules are defined using `android_binary`. Android rules for testing are `android_instrumentation_test` and `android_local_test`.
+
+**[BUILD files](https://github.com/oppia/oppia-android/blob/7344270032ac242b1b8987f1b51c8b5aa4f14ce3/app/BUILD.bazel#L3)**
+
+Every package contains a BUILD file. This file is written in Starlark Language. In this Build file for module-level, we generally define `android_library`, `kt_android_library` to build our package files as per the requirement.
+
+**[Dependencies](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/BUILD.bazel#L16)**
+
+A target A depends upon a target B if B is needed by A at build. `A -> B`
+
+```
+deps = [ "//app",]
+```
+Here, `deps` is used to define the dependencies which is a type of dependencies called `deps dependencies` and it includes the files/directory/target which are dependent. From the above example the dependency is the `app` target which is defined in the [Build file of app package](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/app/BUILD.bazel#L616).
+
+Example of Dependencies
+1. [srcs dependencies](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/app/BUILD.bazel#L617)
+2. [deps dependencies](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/app/BUILD.bazel#L622)
+
+**[Loading an extension](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/app/BUILD.bazel#L13)**
+
+Bazel extensions are files ending in .bzl. Use the load statement to import a symbol from an extension.
+
+```
+load("@io_bazel_rules_kotlin//kotlin:android.bzl", "kt_android_library")
+```
+Here, we are loading `android.bzl` and we are going to use it with a symbol name `kt_android_library`.
+Arguments to the load function must be string literals. load statements must appear at top-level in the file.
+
+**[Visibility of a file target](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/app/BUILD.bazel#L621)**
+
+With the example from our codebase, target `app` whose visibility is public. 
+
+ - `visibility = ["//visibility:public"],` - Anyone can use this target.
+ - `"//visibility:private"` - Only targets in this package can use this target.
+
+**[Testing](https://github.com/oppia/oppia-android/blob/7344270032ac242b1b8987f1b51c8b5aa4f14ce3/app/src/sharedTest/java/org/oppia/android/app/player/exploration/BUILD.bazel#L7)**
+
+when we want to run test cases on Bazel build environment, a test target needs to be set up correctly:
+
+```bazel
+load("//:oppia_android_test.bzl", "oppia_android_test")
+
+oppia_android_test(
+    name = "MathExpressionInteractionsViewTest",
+    srcs = [
+        "MathExpressionInteractionsViewTest.kt",
+        "//app:data_binder_mapper_impl"
+    ],
+    custom_package = "org.oppia.android.app.test",
+    test_manifest = "//app:test_manifest",
+    enable_data_binding = True,
+    test_class = "org.oppia.android.app.customview.interaction.MathExpressionInteractionsViewTest",
+    deps = [
+      ...
+    ],
+)
+```
+
+The above assumes that the corresponding test requires resources. If it doesn't, the definition can be a bit simpler:
+
+```bazel
+load("//:oppia_android_test.bzl", "oppia_android_test")
+
+oppia_android_test(
+    name = "MathExpressionAccessibilityUtilTest",
+    srcs = ["MathExpressionAccessibilityUtilTest.kt"],
+    custom_package = "org.oppia.android.app.utility.math",
+    test_manifest = "//app:test_manifest",
+    test_class = "org.oppia.android.app.utility.math.MathExpressionAccessibilityUtilTest",
+    deps = [
+      ...
+    ],
+)
+```
+
+## Syncing the Project
+The IntelliJ Bazel Plugin's Sync process has a purpose to query Bazel for information and build up IntelliJ's project structure to fit Bazel's model.
+
+It runs automatically during a project import, and manually by either clicking on the sync icon in the menu bar or, partially syncing packages and individual files in contextual menus.
+
+Running a sync generates a `.aswb` directory in the project root. 
+
+### Structure of the .aswb
+The `.aswb` is known as the **project directory**. It contains metadata about the project that bridges Bazel and IntelliJ project models.
+```
+.aswb/
+├── .bazelproject
+├── .blaze
+│   ├── aar_libraries
+│   ├── modules
+│   ├── remoteOutputCache 
+│   └── renderjars
+└── .idea
+```
+
+The `.bazelproject` is the project view file which contains project-wide settings, like targets to sync, Bazel flags, and enabled languages. It is used to import a subset of Bazel packages into the IDE. The project view determines which rules are imported and how. Read more information [here](https://ij.bazel.build/docs/project-views.html).
+
+The `.blaze` is the Bazel data subdirectory, containing mostly IntelliJ module definitions. 
+  - `modules` directory contains IntelliJ module definition files.
+  - `remoteOutputCache` is a general-purpose local cache for output artifacts generated remotely. During a project sync, updated outputs of interest will be copied locally.
+  - `aar_libraries` is the location of the plugin's JAR cache. This helps provide a more robust code navigation experience, but with the possibility of missing changes made by Bazel outside of the IDE view.
+
+The `.idea` directory contains project-specific settings files managed by IntelliJ. IntelliJ reads XML files in this directory to set up the Project Structure: project, modules, libraries, SDKs, facets.
+
+### Syncing (and Partial Syncing) the Bazel Plugin in Android Studio
+When you make certain changes to your project files, you need to sync your project with Bazel to pick up those changes. For example:
+* Changing a BUILD file, like adding a new target, or adding dependencies and sources to a target.
+* Changing generated output files required to resolve source code, like annotation processor outputs such as AutoValue-generated classes.
+
+You can sync with Bazel in two ways:
+* From your IDE’s menu, click **Bazel > Sync > Sync Project with BUILD files.**
+* From the toolbar, click the **Sync Project with BUILD files** button.
+
+**Expand Sync to Working Set**
+
+Your working set is any files your VCS says are dirty, roughly corresponding to something like git status. By default the plugin tries to expand the sync to cover any target in your working set. This ensures these files are refreshed without having to go to the trouble of adding a temporary target to your project view.
path: wiki/Bazel-User-Guide.md
user: login: subhajitxyz
body: Missing a comma.
```suggestion
Your working set is any files your VCS says are dirty, roughly corresponding to something like git status. By default, the plugin tries to expand the sync to cover any target in your working set. This ensures these files are refreshed without having to go to the trouble of adding a temporary target to your project view.
```
created_at: 2025-03-26T13:30:36Z
author_association: COLLABORATOR
diff_hunk: @@ -5,32 +5,322 @@ This wiki page explains how to install Oppia Android on your local machine. If y
 ## Table of Contents
 
 - [Prepare developer environment](#prepare-developer-environment)
+- [Install Bazel](#install-bazel)
+  - [Bazel Set up for Mac](#bazel-set-up-for-mac)
+  - [Bazel Set up for Linux](#bazel-set-up-for-linux)
+  - [Bazel Set up for Windows](#bazel-set-up-for-windows)
 - [Install oppia-android](#install-oppia-android)
-- [Run the app from Android Studio](#run-the-app-from-android-studio)
+- [Opening the Project in Android Studio](#opening-the-project-in-android-studio)
 - [Set up and Run tests](#set-up-and-run-tests)
-  - [Step-by-Step guidance for setting up and running app modules robolectric test](#step-by-step-guidance-for-setting-up-and-running-app-modules-robolectric-test)
-  - [For tests that are in non-app modules, such as **domain** or **utility**:](#for-tests-that-are-in-non-app-modules-such-as-domain-or-utility)
-
+  - [Running app module tests](#running-app-module-tests)
+  - [Running non-app module tests](#running-non-app-module-tests)
+- [Next Steps](#next-steps)
+- [Troubleshooting Installation](#troubleshooting-installation)
 
 ## Prepare developer environment
 
-1. Download/Install [Android Studio Bumblebee | Patch 3](https://developer.android.com/studio/archive).
+1. Download and install Android Studio **Giraffe** from [this location](https://developer.android.com/studio/archive).
+   **Note**: You may try newer or older versions of Android Studio, but we can't guarantee good support.
 
-   **Note**: We recommend installing **Android Studio Bumblebee | 2021.1.1 Patch 3** because newer versions of Android Studio[ do not support running tests where shared source sets are used](https://issuetracker.google.com/issues/232007221#comment18), a configuration we use at Oppia.
+2. Configure your Android Studio
+   - From your PC's application menu, open Android Studio. 
+   - On the welcome screen, find the "more options menu" and select **SDK Manager**
+     
+     <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/efcc4e6e-b6ba-44fc-9c96-aa381de83911" />
+    
+   - In the "SDK Platforms" tab (which is the default), select `API Level 30` and also `API Level 34`.
+   - Also, navigate to the "SDK Tools" tab, click the "Show Package Details" checkbox at the bottom right, then click on "Android SDK Build-Tools 34-rc1" and select 32.0.0 (this is needed for Bazel support).
 
-   **Direct download Url**: [Windows](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-windows.exe) | [Linux](https://redirector.gvt1.com/edgedl/android/studio/ide-zips/2021.1.1.23/android-studio-2021.1.1.23-linux.tar.gz) | [Intel Mac](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-mac.dmg) | [Apple Silicon Mac](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-mac_arm.dmg)
+   - Then, click "Apply" to download and install these two SDKs/Tools.
+     - On this screen, note the **Android SDK Location**, which is set as the ANDROID_HOME variable in the Bazel setup step below.
 
-   You can have multiple versions of Android Studio installed on your machine at the same time.
+3. Prepare a test device
+   You require a physical Android device or an Android emulator to run the Oppia app. 
+   - Physical devices are useful for a real-user experience feel, and testing with [accessibility tools](https://github.com/oppia/oppia-android/wiki/Accessibility-A11y-Guide#setting-up-accessibility-scanner-and-talkback).
+   
+     **Set up a physical device for development**
+      - On the device, open the **Settings** app, select **Developer options**, and then **enable USB debugging** (if applicable).
+        - If you don't see **Developer options**, you might need to enable developer mode first. Follow [these instructions](https://developer.android.com/studio/debug/dev-options#enable) to do so.
+        - Connect to your device using USB.
+        - Verify that your device is connected by running the `adb devices` command from your terminal.
+   
+      - Emulators provide the flexibility of testing the application on a variety of devices and Android API levels without needing to have each physical device.
+   
+     **Set up an Emulator**
+      - For the best experience, you should use the emulator in Android Studio on a computer with at least the following specs:
+        - 16 GB RAM
+        - 64-bit Windows 10 or higher, MacOS 12 or higher, Linux, or ChromeOS operating system
+        - 16 GB disk space
+     
+      - If you don't have these specs, the emulator might still run but not smoothly. In this case, consider testing on a physical device.
 
-2. Configure your Android Studio
-   - In Android Studio, open Tools > SDK Manager.
-     - In the "SDK Platforms" tab (which is the default), select `API Level 28` and also `API Level 30` (for Bazel support).
-     - Also, navigate to the "SDK Tools" tab, click the "Show Package Details" checkbox at the bottom right, then click on "Android SDK Build-Tools 34-rc1" and select 32.0.0 (this is needed for Bazel support).
+      - On the welcome screen, find the "more options menu" and select **Virtual Device Manager**
+     
+        <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/efcc4e6e-b6ba-44fc-9c96-aa381de83911" />
+         
+        * If you already have a project open in Android Studio, in the right hand toolbar, locate `device Manager`.
path: wiki/Installing-Oppia-Android.md
user: login: subhajitxyz
body: ```suggestion
        * If you already have a project open in Android Studio, in the right hand toolbar, locate `Device Manager`.
```
created_at: 2025-03-26T13:36:34Z
author_association: COLLABORATOR
diff_hunk: @@ -5,32 +5,322 @@ This wiki page explains how to install Oppia Android on your local machine. If y
 ## Table of Contents
 
 - [Prepare developer environment](#prepare-developer-environment)
+- [Install Bazel](#install-bazel)
+  - [Bazel Set up for Mac](#bazel-set-up-for-mac)
+  - [Bazel Set up for Linux](#bazel-set-up-for-linux)
+  - [Bazel Set up for Windows](#bazel-set-up-for-windows)
 - [Install oppia-android](#install-oppia-android)
-- [Run the app from Android Studio](#run-the-app-from-android-studio)
+- [Opening the Project in Android Studio](#opening-the-project-in-android-studio)
 - [Set up and Run tests](#set-up-and-run-tests)
-  - [Step-by-Step guidance for setting up and running app modules robolectric test](#step-by-step-guidance-for-setting-up-and-running-app-modules-robolectric-test)
-  - [For tests that are in non-app modules, such as **domain** or **utility**:](#for-tests-that-are-in-non-app-modules-such-as-domain-or-utility)
-
+  - [Running app module tests](#running-app-module-tests)
+  - [Running non-app module tests](#running-non-app-module-tests)
+- [Next Steps](#next-steps)
+- [Troubleshooting Installation](#troubleshooting-installation)
 
 ## Prepare developer environment
 
-1. Download/Install [Android Studio Bumblebee | Patch 3](https://developer.android.com/studio/archive).
+1. Download and install Android Studio **Giraffe** from [this location](https://developer.android.com/studio/archive).
+   **Note**: You may try newer or older versions of Android Studio, but we can't guarantee good support.
 
-   **Note**: We recommend installing **Android Studio Bumblebee | 2021.1.1 Patch 3** because newer versions of Android Studio[ do not support running tests where shared source sets are used](https://issuetracker.google.com/issues/232007221#comment18), a configuration we use at Oppia.
+2. Configure your Android Studio
+   - From your PC's application menu, open Android Studio. 
+   - On the welcome screen, find the "more options menu" and select **SDK Manager**
+     
+     <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/efcc4e6e-b6ba-44fc-9c96-aa381de83911" />
+    
+   - In the "SDK Platforms" tab (which is the default), select `API Level 30` and also `API Level 34`.
+   - Also, navigate to the "SDK Tools" tab, click the "Show Package Details" checkbox at the bottom right, then click on "Android SDK Build-Tools 34-rc1" and select 32.0.0 (this is needed for Bazel support).
 
-   **Direct download Url**: [Windows](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-windows.exe) | [Linux](https://redirector.gvt1.com/edgedl/android/studio/ide-zips/2021.1.1.23/android-studio-2021.1.1.23-linux.tar.gz) | [Intel Mac](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-mac.dmg) | [Apple Silicon Mac](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-mac_arm.dmg)
+   - Then, click "Apply" to download and install these two SDKs/Tools.
+     - On this screen, note the **Android SDK Location**, which is set as the ANDROID_HOME variable in the Bazel setup step below.
 
-   You can have multiple versions of Android Studio installed on your machine at the same time.
+3. Prepare a test device
+   You require a physical Android device or an Android emulator to run the Oppia app. 
+   - Physical devices are useful for a real-user experience feel, and testing with [accessibility tools](https://github.com/oppia/oppia-android/wiki/Accessibility-A11y-Guide#setting-up-accessibility-scanner-and-talkback).
+   
+     **Set up a physical device for development**
+      - On the device, open the **Settings** app, select **Developer options**, and then **enable USB debugging** (if applicable).
+        - If you don't see **Developer options**, you might need to enable developer mode first. Follow [these instructions](https://developer.android.com/studio/debug/dev-options#enable) to do so.
+        - Connect to your device using USB.
+        - Verify that your device is connected by running the `adb devices` command from your terminal.
+   
+      - Emulators provide the flexibility of testing the application on a variety of devices and Android API levels without needing to have each physical device.
+   
+     **Set up an Emulator**
+      - For the best experience, you should use the emulator in Android Studio on a computer with at least the following specs:
+        - 16 GB RAM
+        - 64-bit Windows 10 or higher, MacOS 12 or higher, Linux, or ChromeOS operating system
+        - 16 GB disk space
+     
+      - If you don't have these specs, the emulator might still run but not smoothly. In this case, consider testing on a physical device.
 
-2. Configure your Android Studio
-   - In Android Studio, open Tools > SDK Manager.
-     - In the "SDK Platforms" tab (which is the default), select `API Level 28` and also `API Level 30` (for Bazel support).
-     - Also, navigate to the "SDK Tools" tab, click the "Show Package Details" checkbox at the bottom right, then click on "Android SDK Build-Tools 34-rc1" and select 32.0.0 (this is needed for Bazel support).
+      - On the welcome screen, find the "more options menu" and select **Virtual Device Manager**
+     
+        <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/efcc4e6e-b6ba-44fc-9c96-aa381de83911" />
+         
+        * If you already have a project open in Android Studio, in the right hand toolbar, locate `device Manager`.
+      - Click the **+**, and then click **Create Virtual Device**.
+      - Follow the wizard to create a phone and a tablet AVD, setting the **system image** to be one of `API Level 30` or `API Level 34` as installed above.
+      - After creating your devices, you will be able to see a list of all the devices on the device manager panel.
+      - For more information on the different configurations available for AVDs, please visit the [official documentation page.](https://developer.android.com/studio/run/managing-avds)
 
-   - Then, click "Apply" to download and install these two SDKs/Tools.
+## Install Bazel
+### Instructions
+
+**The steps to setting up Bazel are:**
+1. Install Bazel
+2. Set Bazel and ANDROID_HOME paths permanently in your terminal
+3. Verify that the build is working
+
+The expected output of `bazel --version` once Bazel set up is successful is:
+
+```
+bazel 6.5.0
+```
+
+### Bazel Set up for Mac
+It is recommended to use the binary installer steps outline below. For other ways to install Bazel on Mac, refer to the [official page](https://bazel.build/install/os-x).
path: wiki/Installing-Oppia-Android.md
user: login: subhajitxyz
body: ```suggestion
It is recommended to use the binary installer steps outlined below. For other ways to install Bazel on Mac, refer to the [official page](https://bazel.build/install/os-x).
```
created_at: 2025-03-26T13:51:39Z
author_association: COLLABORATOR
diff_hunk: @@ -5,32 +5,322 @@ This wiki page explains how to install Oppia Android on your local machine. If y
 ## Table of Contents
 
 - [Prepare developer environment](#prepare-developer-environment)
+- [Install Bazel](#install-bazel)
+  - [Bazel Set up for Mac](#bazel-set-up-for-mac)
+  - [Bazel Set up for Linux](#bazel-set-up-for-linux)
+  - [Bazel Set up for Windows](#bazel-set-up-for-windows)
 - [Install oppia-android](#install-oppia-android)
-- [Run the app from Android Studio](#run-the-app-from-android-studio)
+- [Opening the Project in Android Studio](#opening-the-project-in-android-studio)
 - [Set up and Run tests](#set-up-and-run-tests)
-  - [Step-by-Step guidance for setting up and running app modules robolectric test](#step-by-step-guidance-for-setting-up-and-running-app-modules-robolectric-test)
-  - [For tests that are in non-app modules, such as **domain** or **utility**:](#for-tests-that-are-in-non-app-modules-such-as-domain-or-utility)
-
+  - [Running app module tests](#running-app-module-tests)
+  - [Running non-app module tests](#running-non-app-module-tests)
+- [Next Steps](#next-steps)
+- [Troubleshooting Installation](#troubleshooting-installation)
 
 ## Prepare developer environment
 
-1. Download/Install [Android Studio Bumblebee | Patch 3](https://developer.android.com/studio/archive).
+1. Download and install Android Studio **Giraffe** from [this location](https://developer.android.com/studio/archive).
+   **Note**: You may try newer or older versions of Android Studio, but we can't guarantee good support.
 
-   **Note**: We recommend installing **Android Studio Bumblebee | 2021.1.1 Patch 3** because newer versions of Android Studio[ do not support running tests where shared source sets are used](https://issuetracker.google.com/issues/232007221#comment18), a configuration we use at Oppia.
+2. Configure your Android Studio
+   - From your PC's application menu, open Android Studio. 
+   - On the welcome screen, find the "more options menu" and select **SDK Manager**
+     
+     <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/efcc4e6e-b6ba-44fc-9c96-aa381de83911" />
+    
+   - In the "SDK Platforms" tab (which is the default), select `API Level 30` and also `API Level 34`.
+   - Also, navigate to the "SDK Tools" tab, click the "Show Package Details" checkbox at the bottom right, then click on "Android SDK Build-Tools 34-rc1" and select 32.0.0 (this is needed for Bazel support).
 
-   **Direct download Url**: [Windows](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-windows.exe) | [Linux](https://redirector.gvt1.com/edgedl/android/studio/ide-zips/2021.1.1.23/android-studio-2021.1.1.23-linux.tar.gz) | [Intel Mac](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-mac.dmg) | [Apple Silicon Mac](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-mac_arm.dmg)
+   - Then, click "Apply" to download and install these two SDKs/Tools.
+     - On this screen, note the **Android SDK Location**, which is set as the ANDROID_HOME variable in the Bazel setup step below.
 
-   You can have multiple versions of Android Studio installed on your machine at the same time.
+3. Prepare a test device
+   You require a physical Android device or an Android emulator to run the Oppia app. 
+   - Physical devices are useful for a real-user experience feel, and testing with [accessibility tools](https://github.com/oppia/oppia-android/wiki/Accessibility-A11y-Guide#setting-up-accessibility-scanner-and-talkback).
+   
+     **Set up a physical device for development**
+      - On the device, open the **Settings** app, select **Developer options**, and then **enable USB debugging** (if applicable).
+        - If you don't see **Developer options**, you might need to enable developer mode first. Follow [these instructions](https://developer.android.com/studio/debug/dev-options#enable) to do so.
+        - Connect to your device using USB.
+        - Verify that your device is connected by running the `adb devices` command from your terminal.
+   
+      - Emulators provide the flexibility of testing the application on a variety of devices and Android API levels without needing to have each physical device.
+   
+     **Set up an Emulator**
+      - For the best experience, you should use the emulator in Android Studio on a computer with at least the following specs:
+        - 16 GB RAM
+        - 64-bit Windows 10 or higher, MacOS 12 or higher, Linux, or ChromeOS operating system
+        - 16 GB disk space
+     
+      - If you don't have these specs, the emulator might still run but not smoothly. In this case, consider testing on a physical device.
 
-2. Configure your Android Studio
-   - In Android Studio, open Tools > SDK Manager.
-     - In the "SDK Platforms" tab (which is the default), select `API Level 28` and also `API Level 30` (for Bazel support).
-     - Also, navigate to the "SDK Tools" tab, click the "Show Package Details" checkbox at the bottom right, then click on "Android SDK Build-Tools 34-rc1" and select 32.0.0 (this is needed for Bazel support).
+      - On the welcome screen, find the "more options menu" and select **Virtual Device Manager**
+     
+        <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/efcc4e6e-b6ba-44fc-9c96-aa381de83911" />
+         
+        * If you already have a project open in Android Studio, in the right hand toolbar, locate `device Manager`.
+      - Click the **+**, and then click **Create Virtual Device**.
+      - Follow the wizard to create a phone and a tablet AVD, setting the **system image** to be one of `API Level 30` or `API Level 34` as installed above.
+      - After creating your devices, you will be able to see a list of all the devices on the device manager panel.
+      - For more information on the different configurations available for AVDs, please visit the [official documentation page.](https://developer.android.com/studio/run/managing-avds)
 
-   - Then, click "Apply" to download and install these two SDKs/Tools.
+## Install Bazel
+### Instructions
+
+**The steps to setting up Bazel are:**
+1. Install Bazel
+2. Set Bazel and ANDROID_HOME paths permanently in your terminal
+3. Verify that the build is working
+
+The expected output of `bazel --version` once Bazel set up is successful is:
+
+```
+bazel 6.5.0
+```
+
+### Bazel Set up for Mac
+It is recommended to use the binary installer steps outline below. For other ways to install Bazel on Mac, refer to the [official page](https://bazel.build/install/os-x).
+
+**Step 1: Install Xcode command line tools**
+
+In macOS 14 or earlier, it is sufficient to install the Xcode command line tools package by using xcode-select:
+
+```
+xcode-select --install
+```
+
+Otherwise, for macOS 15 and later, you must have Xcode 6.1 or later installed on your system.
+
+Download Xcode from the [App Store](https://apps.apple.com/us/app/xcode/id497799835) or the [Apple Developer site](https://developer.apple.com/download/more/?=xcode).
+
+Once Xcode is installed, accept the license agreement for all users with the following command:
+
+```
+sudo xcodebuild -license accept
+```
+
+**Step 2: Download the Bazel installer**
+
+Click [here](https://github.com/bazelbuild/bazel/releases/download/6.5.0/bazel-6.5.0-installer-darwin-x86_64.sh) to download the Bazel 6.5.0 binary installer.
+
+**Step 3: Run the installer**
+
+Run the Bazel installer as follows:
+
+```shell
+chmod +x "bazel-6.5.0-installer-darwin-x86_64.sh"
+./bazel-6.5.0-installer-darwin-x86_64.sh --user
+```
+
+**Step 4: Set up your environment**
+
+You must set the path for `Bazel` and `ANDROID_HOME` before running bazel build for oppia-android, otherwise you will get an error.
+
+If you ran the Bazel installer with the `--user` flag as above, the Bazel executable is installed in your $HOME/bin directory. It’s a good idea to add this directory to your default paths, as follows:
+
+```shell
+export PATH="$PATH:$HOME/bin"
+```
+
+To set the `ANDROID_HOME` path permanently in your terminal run these commands:
+
+```
+sudo nano /etc/paths
+```
+- Enter your password, when prompted.
+- Go to the bottom of the file, and enter this path: `$HOME/Library/Android/sdk`
+- Hit control-x to quit.
+- Enter “Y” to save the modified buffer.
+- That’s it! To test it, in a new terminal window, type: `echo $PATH`
+
+**Step 5: Verify that the build is working**
+
+Run the following command in your terminal:
+
+```
+bazel --version
+```
+
+### Bazel Set up for Linux
+This section covers Bazel installation on Ubuntu. 
+
+Recommendations:
+- use Ubuntu 18.04 (LTS), 20.04 (LTS), or 22.04 (LTS).
+- use ``apt`` installation instructions.
+
+- **Note**: if you encounter any errors related to `cURL`, please set up cURL on your machine using `sudo apt install curl`.
+
+**Step 1: Add Bazel distribution URI as a package source**
+
+This is a one-time setup step.
+
+```
+sudo apt install apt-transport-https curl gnupg -y
+curl -fsSL https://bazel.build/bazel-release.pub.gpg | gpg --dearmor >bazel-archive-keyring.gpg
+sudo mv bazel-archive-keyring.gpg /usr/share/keyrings
+echo "deb [arch=amd64 signed-by=/usr/share/keyrings/bazel-archive-keyring.gpg] https://storage.googleapis.com/bazel-apt stable jdk1.8" | sudo tee /etc/apt/sources.list.d/bazel.list
+```
+
+**Step 2: Install and update Bazel**
+
+Run:
+```shell
+sudo apt-get update && sudo apt-get install bazel-6.5.0
+```
+
+**Step 3: Set up your environment**
+
+Ensure that your `ANDROID_HOME` environment variable is set to the location of your Android SDK. Assuming the SDK is installed to default locations, you can use the following commands to set the `ANDROID_HOME` variable:
+
+```
+export ANDROID_HOME=$HOME/Android/Sdk/
+```
+
+**Step 4: Verify that the build is working**
+
+Run the following command in your terminal:
+
+```
+bazel --version
+```
+
+### Bazel Set up for Windows
+This page outlines one way to allow Bazel to be used in CLI form on Windows. Please note that **this support is currently experimental**. We suggest that you post a discussion at [github-discussions](https://github.com/oppia/oppia-android/discussions/categories/q-a-installation) if you run into any problems.
+
+Unlike Unix-based systems where Bazel runs natively without issue, the current solution on Windows is to install an Ubuntu-based subsystem. Windows currently only supports a terminal experience in this subsystem (though there is a prerelease version of the software with GUI support) which means Android Studio will not be supported. You will need to continue using the Windows version of Android Studio and only use the Linux subsystem for building & running Robolectric or JUnit-based tests.
+
+Due to the issues mentioned above, we recommend dual-booting your PC with Linux. However, if you choose to use Windows, please follow the instructions below:
+
+**Main prerequisites**:
+- Windows 10+: These instructions are geared towards users of Windows 10+ (older versions will not be compatible). If you're in using an older version of Windows, please follow up with a comment on [this issue](https://github.com/oppia/oppia-android/issues/3371).
path: wiki/Installing-Oppia-Android.md
user: login: subhajitxyz
body: ```suggestion
- Windows 10+: These instructions are geared towards users of Windows 10+ (older versions will not be compatible). If you're using an older version of Windows, please follow up with a comment on [this issue](https://github.com/oppia/oppia-android/issues/3371).
```
created_at: 2025-03-26T13:59:40Z
author_association: COLLABORATOR
diff_hunk: @@ -150,8 +451,105 @@ We strongly recommend running tests on Robolectric which is faster because it do
 
 - To learn about how we write tests at oppia-android, please refer to: [Oppia Android Testing](https://github.com/oppia/oppia-android/wiki/Oppia-Android-Testing).
 
-- To get started with Bazel, please see [Oppia-Bazel-Setup-Instructions](https://github.com/oppia/oppia-android/wiki/Oppia-Bazel-Setup-Instructions) and follow the instructions appropriate to your OS.
-
-- If you run into any issues during your setup, search our [discussions](https://github.com/oppia/oppia-android/discussions) forum or start a new discussion.
-
-- Please see  [Troubleshooting-Installation](https://github.com/oppia/oppia-android/wiki/Troubleshooting-Installation) for solutions to some common setup issues.
+- An important reference to go back to as you continue developing with Bazel is the [Bazel User Guide](https://github.com/oppia/oppia-android/wiki/Bazel-User-Guide).
+
+### Troubleshooting Installation
+#### General issues
+1. If the Static Checks on your PR keeps failing, please refer to [instructions on running static checks locally](https://github.com/oppia/oppia-android/wiki/Static-Analysis-Checks#how-to-run-static-checks-locally) in order to catch these errors before pushing.
path: wiki/Installing-Oppia-Android.md
user: login: subhajitxyz
body: ‘keeps’ should be ‘keep’ to match the plural subject.
```suggestion
1. If the Static Checks on your PR keep failing, please refer to [instructions on running static checks locally](https://github.com/oppia/oppia-android/wiki/Static-Analysis-Checks#how-to-run-static-checks-locally) in order to catch these errors before pushing.
```
created_at: 2025-03-26T14:07:03Z
author_association: COLLABORATOR
diff_hunk: @@ -264,7 +264,7 @@ To fix failing tests from GitHub CI individually, follow the steps below.
 - Alternatively, in Android Studio, go to the `.github` folder and find the [static_checks.yml](https://github.com/oppia/oppia-android/blob/develop/.github/workflows/static_checks.yml) file. Search for the line that corresponds to the name of the job that failed. You can then run the same script on your local terminal.
 - You can also go to scripts/static_checks.sh to view the failing check and run it locally.
 
-Note: Before running the script command in your local terminal, make sure you have Bazel installed. To learn how to set up Bazel for Oppia Android, follow these [instructions](https://github.com/oppia/oppia-android/wiki/Oppia-Bazel-Setup-Instructions). Also make sure you have oppia-android-tools installed since static checks rely on these tools to be able to perform some of the checks. To install oppia-android-tools, run `bash scripts/setup.sh` in the oppia-android directory.
+Note: Before running the script command in your local terminal, make sure you have Bazel installed. To learn how to set up Bazel for Oppia Android, follow these [instructions](https://github.com/oppia/oppia-android/wiki/Installing-Oppia-Android#install-bazel). Also make sure you have oppia-android-tools installed since static checks rely on these tools to be able to perform some of the checks. To install oppia-android-tools, run `bash scripts/setup.sh` in the oppia-android directory.
path: wiki/Static-Analysis-Checks.md
user: login: subhajitxyz
body: Missing a comma.
```suggestion
Note: Before running the script command in your local terminal, make sure you have Bazel installed. To learn how to set up Bazel for Oppia Android, follow these [instructions](https://github.com/oppia/oppia-android/wiki/Installing-Oppia-Android#install-bazel). Also, make sure you have oppia-android-tools installed since static checks rely on these tools to be able to perform some of the checks. To install oppia-android-tools, run `bash scripts/setup.sh` in the oppia-android directory.
```
created_at: 2025-03-26T14:10:10Z
author_association: COLLABORATOR
diff_hunk: @@ -0,0 +1,284 @@
+## Table of Contents
+
+- [Overview](#overview)
+- [Installation](#installation)
+  - [Building the app](#building-the-app)
+- [Running Tests](#running-tests)
+  - [How to Obtain a Test Target](#how-to-obtain-a-test-target)
+  - [Common Flags](#common-flags)
+  - [Running multiple test targets](#running-multiple-test-targets)
+- [Concepts and Terminology](#concepts-and-terminology)
+- [Syncing the Project](#syncing-the-project)
+
+## Overview
+Bazel is an open-source build and test tool similar to Make, Maven, and Gradle. It uses a human-readable, high-level build language.
+
+## Installation
+
+Follow the instructions on the [installation page](https://github.com/oppia/oppia-android/wiki/Installing-Oppia-Android#install-bazel) to set up Bazel.
+
+### Building the app
+
+The [installation page](https://github.com/oppia/oppia-android/wiki/Installing-Oppia-Android#install-bazel) provides information on running the project in Android Studio.
+
+You can also run the app from the command line using the commands detailed below.
+
+Using the command line is helpful in instances when you need to build and run some targets outside of Android Studio.
+
+Run the following commands in your terminal. All Bazel commands must be run from the root of the `oppia-android` directory otherwise they will fail.
+
+Note that on the first run, these commands may take 10-20 minutes to complete depending on the performance of your machine. Subsequent runs will be much faster.
+
+**On SDK 29 and below, run**:
+   ```
+   bazel mobile-install //:oppia_dev_binary
+   ```
+This will build, install and launch the app on your device.
+
+**On SDK 30 and newer, run**:
+   ```
+   bazel build //:oppia_dev
+   ```
+followed by:
+   ```
+   adb install bazel-bin/oppia_dev_binary.apk  
+   ```
+* Starting from SDK 30, incremental builds, like those executed using `bazel mobile-install`, are no longer permitted, necessitating the use of two separate commands.
+
+If everything is working, you should see output like the following:
+
+```
+Target //:oppia_dev_binary up-to-date:
+  bazel-bin/oppia_dev_binary_deploy.jar
+  bazel-bin/oppia_dev_binary_unsigned.apk
+  bazel-bin/oppia_dev_binary.apk
+INFO: Elapsed time: 37.155s, Critical Path: 17.24s
+INFO: 99 processes: 2 internal, 23 darwin-sandbox, 74 worker.
+INFO: Build completed successfully, 99 total actions
+Performing Streamed Install
+Success
+```
+
+Note also that the ``oppia_dev.aab`` under the ``bazel-bin`` directory of your local copy of Oppia Android should be a fully functioning development version of the app that can be installed using bundle-tool. However, it's recommended to deploy Oppia to an emulator or connected device using the `mobile-install` command.
+
+## Running Tests
+
+The bazel test command is used to build and run tests in a Bazel workspace. It ensures that the specified test targets are built and executed in a sandboxed environment for reproducibility.
+
+**Syntax**
+
+```shell
+bazel test //path/to:target
+```
+
+### How to Obtain a Test Target
+A test target in Bazel refers to a specific testable entity defined in a BUILD file. It represents a test rule, such as `java_test` or `android_test`, that Bazel can build and execute.
+
+To ensure you always use the correct test target, follow one of these steps:
+1. If the test file is open in Android Studio:
+   * Right-click to open the context menu and select **Copy BUILD target string** as shown.
+     
+     ![Screenshot 2025-03-18 at 22 30 22](https://github.com/user-attachments/assets/286ebcb6-4f4e-4055-b6f0-4c070b039375)
+   
+   * Paste the target to the bazel test command, e.g. `bazel test //domain/src/test/java/org/oppia/android/domain/onboarding:AppStartupStateControllerTest`
+
+2. If the test file is open in Android Studio, but **Copy BUILD target string** is not available in the context menu:
+Sometimes the **Copy BUILD target string** is not available in the context menu either due to sync issues or modularization issues. You can still copy the file path, and pass it to the test command.
+   * In the AS sidebar, right click on the file, and select `copy path/reference`.
+     or
+   * Right-click on the file tab and then click `copy path/reference`.
+   * Next, select `copy path from repository root`. 
+   * Paste the copied path to the bazel test command in the terminal and remove the `.kt` extension, e.g. `bazel test domain/src/test/java/org/oppia/android/domain/onboarding/AppStartupStateControllerTest`.
+
+With this syntax, Bazel implicitly converts the file path into a target if it matches a test rule in the BUILD file. If the file is not part of a test target in the BUILD file, this command may fail.
+**When to use this**: If you are unsure about the exact Bazel target and want a quick way to run a test.
+
+3. Querying for a target
+Using the explicit Bazel target (// syntax) is more reliable compared to the file path syntax above. However, in cases such as running the test outside android studio, you may not know the target. In this case, you can use Bazel's `query` command to retrieve the correct test target:
+   * Copy the relative path of the test file.
+   * Run the following command in your terminal to get the test’s Bazel target: `bazel query relative-path-of-test-file`
+   Example
+   
+   ```shell
+   bazel query domain/src/test/java/org/oppia/android/domain/onboarding/AppStartupStateControllerTest.kt
+   ```
+   * The output will be a Bazel target that starts with //. Copy the target and remove the .kt extension.
+   * Use this target in the bazel test command, e.g. `bazel test //domain/src/test/java/org/oppia/android/domain/onboarding:AppStartupStateControllerTest`.
+
+### Common Flags
+
+`--test_output=all` → Show full test output.
+`--cache_test_results=no` → Force re-running tests even if cached.
+`--test_filter=ClassName#methodName` → Run specific test cases.
+`--runs_per_test=100` → Specifies number of times to run each test.
+
+### Running multiple test targets
+To run all the test targets in the app module:
+
+```
+bazel test //app/...
+```
+
+To run all the test targets in the project (note that this would be extremely slow and is not recommended):
+
+```
+bazel test //...
+```
+
+To run multiple test targets at once:
+
+```
+bazel test -- //path/to/target/FirstTest //path/to/target/SecondTest
+```
+
+## Concepts and Terminology
+**[Workspace](https://github.com/oppia/oppia-android/blob/7344270032ac242b1b8987f1b51c8b5aa4f14ce3/WORKSPACE#L2)**
+
+A workspace is a directory where we specify the targeted SDK version, required dependencies, and corresponding Rules. The directory containing the WORKSPACE file is the root of the main repository, which in our case, is the `oppia-android` root directory.
+**[Packages](https://github.com/oppia/oppia-android/tree/develop/app)**
+
+A package is defined as a directory containing a file named BUILD or BUILD.bazel.
+
+**[Binary rules](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/BUILD.bazel#L3)**
+
+A rule specifies the relationship between inputs and outputs, and the steps to build the outputs.
+In Android, rules are defined using `android_binary`. Android rules for testing are `android_instrumentation_test` and `android_local_test`.
+
+**[BUILD files](https://github.com/oppia/oppia-android/blob/7344270032ac242b1b8987f1b51c8b5aa4f14ce3/app/BUILD.bazel#L3)**
+
+Every package contains a BUILD file. This file is written in Starlark Language. In this Build file for module-level, we generally define `android_library`, `kt_android_library` to build our package files as per the requirement.
+
+**[Dependencies](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/BUILD.bazel#L16)**
+
+A target A depends upon a target B if B is needed by A at build. `A -> B`
+
+```
+deps = [ "//app",]
+```
+Here, `deps` is used to define the dependencies which is a type of dependencies called `deps dependencies` and it includes the files/directory/target which are dependent. From the above example the dependency is the `app` target which is defined in the [Build file of app package](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/app/BUILD.bazel#L616).
+
+Example of Dependencies
+1. [srcs dependencies](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/app/BUILD.bazel#L617)
+2. [deps dependencies](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/app/BUILD.bazel#L622)
+
+**[Loading an extension](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/app/BUILD.bazel#L13)**
+
+Bazel extensions are files ending in .bzl. Use the load statement to import a symbol from an extension.
+
+```
+load("@io_bazel_rules_kotlin//kotlin:android.bzl", "kt_android_library")
+```
+Here, we are loading `android.bzl` and we are going to use it with a symbol name `kt_android_library`.
+Arguments to the load function must be string literals. load statements must appear at top-level in the file.
path: wiki/Bazel-User-Guide.md
user: login: subhajitxyz
body: 'load' should start with capital letter.
```suggestion
Arguments to the load function must be string literals. Load statements must appear at top-level in the file.
```
created_at: 2025-03-26T14:13:25Z
author_association: COLLABORATOR
diff_hunk: @@ -0,0 +1,284 @@
+## Table of Contents
+
+- [Overview](#overview)
+- [Installation](#installation)
+  - [Building the app](#building-the-app)
+- [Running Tests](#running-tests)
+  - [How to Obtain a Test Target](#how-to-obtain-a-test-target)
+  - [Common Flags](#common-flags)
+  - [Running multiple test targets](#running-multiple-test-targets)
+- [Concepts and Terminology](#concepts-and-terminology)
+- [Syncing the Project](#syncing-the-project)
+
+## Overview
+Bazel is an open-source build and test tool similar to Make, Maven, and Gradle. It uses a human-readable, high-level build language.
+
+## Installation
+
+Follow the instructions on the [installation page](https://github.com/oppia/oppia-android/wiki/Installing-Oppia-Android#install-bazel) to set up Bazel.
+
+### Building the app
+
+The [installation page](https://github.com/oppia/oppia-android/wiki/Installing-Oppia-Android#install-bazel) provides information on running the project in Android Studio.
+
+You can also run the app from the command line using the commands detailed below.
+
+Using the command line is helpful in instances when you need to build and run some targets outside of Android Studio.
+
+Run the following commands in your terminal. All Bazel commands must be run from the root of the `oppia-android` directory otherwise they will fail.
+
+Note that on the first run, these commands may take 10-20 minutes to complete depending on the performance of your machine. Subsequent runs will be much faster.
+
+**On SDK 29 and below, run**:
+   ```
+   bazel mobile-install //:oppia_dev_binary
+   ```
+This will build, install and launch the app on your device.
+
+**On SDK 30 and newer, run**:
+   ```
+   bazel build //:oppia_dev
+   ```
+followed by:
+   ```
+   adb install bazel-bin/oppia_dev_binary.apk  
+   ```
+* Starting from SDK 30, incremental builds, like those executed using `bazel mobile-install`, are no longer permitted, necessitating the use of two separate commands.
+
+If everything is working, you should see output like the following:
+
+```
+Target //:oppia_dev_binary up-to-date:
+  bazel-bin/oppia_dev_binary_deploy.jar
+  bazel-bin/oppia_dev_binary_unsigned.apk
+  bazel-bin/oppia_dev_binary.apk
+INFO: Elapsed time: 37.155s, Critical Path: 17.24s
+INFO: 99 processes: 2 internal, 23 darwin-sandbox, 74 worker.
+INFO: Build completed successfully, 99 total actions
+Performing Streamed Install
+Success
+```
+
+Note also that the ``oppia_dev.aab`` under the ``bazel-bin`` directory of your local copy of Oppia Android should be a fully functioning development version of the app that can be installed using bundle-tool. However, it's recommended to deploy Oppia to an emulator or connected device using the `mobile-install` command.
+
+## Running Tests
+
+The bazel test command is used to build and run tests in a Bazel workspace. It ensures that the specified test targets are built and executed in a sandboxed environment for reproducibility.
+
+**Syntax**
+
+```shell
+bazel test //path/to:target
+```
+
+### How to Obtain a Test Target
+A test target in Bazel refers to a specific testable entity defined in a BUILD file. It represents a test rule, such as `java_test` or `android_test`, that Bazel can build and execute.
+
+To ensure you always use the correct test target, follow one of these steps:
+1. If the test file is open in Android Studio:
+   * Right-click to open the context menu and select **Copy BUILD target string** as shown.
+     
+     ![Screenshot 2025-03-18 at 22 30 22](https://github.com/user-attachments/assets/286ebcb6-4f4e-4055-b6f0-4c070b039375)
+   
+   * Paste the target to the bazel test command, e.g. `bazel test //domain/src/test/java/org/oppia/android/domain/onboarding:AppStartupStateControllerTest`
+
+2. If the test file is open in Android Studio, but **Copy BUILD target string** is not available in the context menu:
+Sometimes the **Copy BUILD target string** is not available in the context menu either due to sync issues or modularization issues. You can still copy the file path, and pass it to the test command.
+   * In the AS sidebar, right click on the file, and select `copy path/reference`.
+     or
+   * Right-click on the file tab and then click `copy path/reference`.
+   * Next, select `copy path from repository root`. 
+   * Paste the copied path to the bazel test command in the terminal and remove the `.kt` extension, e.g. `bazel test domain/src/test/java/org/oppia/android/domain/onboarding/AppStartupStateControllerTest`.
+
+With this syntax, Bazel implicitly converts the file path into a target if it matches a test rule in the BUILD file. If the file is not part of a test target in the BUILD file, this command may fail.
+**When to use this**: If you are unsure about the exact Bazel target and want a quick way to run a test.
+
+3. Querying for a target
+Using the explicit Bazel target (// syntax) is more reliable compared to the file path syntax above. However, in cases such as running the test outside android studio, you may not know the target. In this case, you can use Bazel's `query` command to retrieve the correct test target:
+   * Copy the relative path of the test file.
+   * Run the following command in your terminal to get the test’s Bazel target: `bazel query relative-path-of-test-file`
+   Example
+   
+   ```shell
+   bazel query domain/src/test/java/org/oppia/android/domain/onboarding/AppStartupStateControllerTest.kt
+   ```
+   * The output will be a Bazel target that starts with //. Copy the target and remove the .kt extension.
+   * Use this target in the bazel test command, e.g. `bazel test //domain/src/test/java/org/oppia/android/domain/onboarding:AppStartupStateControllerTest`.
+
+### Common Flags
+
+`--test_output=all` → Show full test output.
+`--cache_test_results=no` → Force re-running tests even if cached.
+`--test_filter=ClassName#methodName` → Run specific test cases.
+`--runs_per_test=100` → Specifies number of times to run each test.
+
+### Running multiple test targets
+To run all the test targets in the app module:
+
+```
+bazel test //app/...
+```
+
+To run all the test targets in the project (note that this would be extremely slow and is not recommended):
+
+```
+bazel test //...
+```
+
+To run multiple test targets at once:
+
+```
+bazel test -- //path/to/target/FirstTest //path/to/target/SecondTest
+```
+
+## Concepts and Terminology
+**[Workspace](https://github.com/oppia/oppia-android/blob/7344270032ac242b1b8987f1b51c8b5aa4f14ce3/WORKSPACE#L2)**
+
+A workspace is a directory where we specify the targeted SDK version, required dependencies, and corresponding Rules. The directory containing the WORKSPACE file is the root of the main repository, which in our case, is the `oppia-android` root directory.
+**[Packages](https://github.com/oppia/oppia-android/tree/develop/app)**
+
+A package is defined as a directory containing a file named BUILD or BUILD.bazel.
+
+**[Binary rules](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/BUILD.bazel#L3)**
+
+A rule specifies the relationship between inputs and outputs, and the steps to build the outputs.
+In Android, rules are defined using `android_binary`. Android rules for testing are `android_instrumentation_test` and `android_local_test`.
+
+**[BUILD files](https://github.com/oppia/oppia-android/blob/7344270032ac242b1b8987f1b51c8b5aa4f14ce3/app/BUILD.bazel#L3)**
+
+Every package contains a BUILD file. This file is written in Starlark Language. In this Build file for module-level, we generally define `android_library`, `kt_android_library` to build our package files as per the requirement.
+
+**[Dependencies](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/BUILD.bazel#L16)**
+
+A target A depends upon a target B if B is needed by A at build. `A -> B`
path: wiki/Bazel-User-Guide.md
user: login: theayushyadav11
body: ```suggestion
A target A depends upon a target B, if B is needed by A at build. `A -> B`
```
A comma will make it more readable.
created_at: 2025-03-26T14:23:31Z
author_association: COLLABORATOR
diff_hunk: @@ -0,0 +1,284 @@
+## Table of Contents
+
+- [Overview](#overview)
+- [Installation](#installation)
+  - [Building the app](#building-the-app)
+- [Running Tests](#running-tests)
+  - [How to Obtain a Test Target](#how-to-obtain-a-test-target)
+  - [Common Flags](#common-flags)
+  - [Running multiple test targets](#running-multiple-test-targets)
+- [Concepts and Terminology](#concepts-and-terminology)
+- [Syncing the Project](#syncing-the-project)
+
+## Overview
+Bazel is an open-source build and test tool similar to Make, Maven, and Gradle. It uses a human-readable, high-level build language.
+
+## Installation
+
+Follow the instructions on the [installation page](https://github.com/oppia/oppia-android/wiki/Installing-Oppia-Android#install-bazel) to set up Bazel.
+
+### Building the app
+
+The [installation page](https://github.com/oppia/oppia-android/wiki/Installing-Oppia-Android#install-bazel) provides information on running the project in Android Studio.
+
+You can also run the app from the command line using the commands detailed below.
+
+Using the command line is helpful in instances when you need to build and run some targets outside of Android Studio.
+
+Run the following commands in your terminal. All Bazel commands must be run from the root of the `oppia-android` directory otherwise they will fail.
+
+Note that on the first run, these commands may take 10-20 minutes to complete depending on the performance of your machine. Subsequent runs will be much faster.
+
+**On SDK 29 and below, run**:
+   ```
+   bazel mobile-install //:oppia_dev_binary
+   ```
+This will build, install and launch the app on your device.
+
+**On SDK 30 and newer, run**:
+   ```
+   bazel build //:oppia_dev
+   ```
+followed by:
+   ```
+   adb install bazel-bin/oppia_dev_binary.apk  
+   ```
+* Starting from SDK 30, incremental builds, like those executed using `bazel mobile-install`, are no longer permitted, necessitating the use of two separate commands.
+
+If everything is working, you should see output like the following:
+
+```
+Target //:oppia_dev_binary up-to-date:
+  bazel-bin/oppia_dev_binary_deploy.jar
+  bazel-bin/oppia_dev_binary_unsigned.apk
+  bazel-bin/oppia_dev_binary.apk
+INFO: Elapsed time: 37.155s, Critical Path: 17.24s
+INFO: 99 processes: 2 internal, 23 darwin-sandbox, 74 worker.
+INFO: Build completed successfully, 99 total actions
+Performing Streamed Install
+Success
+```
+
+Note also that the ``oppia_dev.aab`` under the ``bazel-bin`` directory of your local copy of Oppia Android should be a fully functioning development version of the app that can be installed using bundle-tool. However, it's recommended to deploy Oppia to an emulator or connected device using the `mobile-install` command.
+
+## Running Tests
+
+The bazel test command is used to build and run tests in a Bazel workspace. It ensures that the specified test targets are built and executed in a sandboxed environment for reproducibility.
+
+**Syntax**
+
+```shell
+bazel test //path/to:target
+```
+
+### How to Obtain a Test Target
+A test target in Bazel refers to a specific testable entity defined in a BUILD file. It represents a test rule, such as `java_test` or `android_test`, that Bazel can build and execute.
+
+To ensure you always use the correct test target, follow one of these steps:
+1. If the test file is open in Android Studio:
+   * Right-click to open the context menu and select **Copy BUILD target string** as shown.
+     
+     ![Screenshot 2025-03-18 at 22 30 22](https://github.com/user-attachments/assets/286ebcb6-4f4e-4055-b6f0-4c070b039375)
+   
+   * Paste the target to the bazel test command, e.g. `bazel test //domain/src/test/java/org/oppia/android/domain/onboarding:AppStartupStateControllerTest`
+
+2. If the test file is open in Android Studio, but **Copy BUILD target string** is not available in the context menu:
+Sometimes the **Copy BUILD target string** is not available in the context menu either due to sync issues or modularization issues. You can still copy the file path, and pass it to the test command.
path: wiki/Bazel-User-Guide.md
user: login: theayushyadav11
body: ```suggestion
Sometimes, the **Copy BUILD target string** is not available in the context menu either due to sync issues or modularization issues. You can still copy the file path, and pass it to the test command.
```
created_at: 2025-03-26T14:30:16Z
author_association: COLLABORATOR
diff_hunk: @@ -5,32 +5,322 @@ This wiki page explains how to install Oppia Android on your local machine. If y
 ## Table of Contents
 
 - [Prepare developer environment](#prepare-developer-environment)
+- [Install Bazel](#install-bazel)
+  - [Bazel Set up for Mac](#bazel-set-up-for-mac)
+  - [Bazel Set up for Linux](#bazel-set-up-for-linux)
+  - [Bazel Set up for Windows](#bazel-set-up-for-windows)
 - [Install oppia-android](#install-oppia-android)
-- [Run the app from Android Studio](#run-the-app-from-android-studio)
+- [Opening the Project in Android Studio](#opening-the-project-in-android-studio)
 - [Set up and Run tests](#set-up-and-run-tests)
-  - [Step-by-Step guidance for setting up and running app modules robolectric test](#step-by-step-guidance-for-setting-up-and-running-app-modules-robolectric-test)
-  - [For tests that are in non-app modules, such as **domain** or **utility**:](#for-tests-that-are-in-non-app-modules-such-as-domain-or-utility)
-
+  - [Running app module tests](#running-app-module-tests)
+  - [Running non-app module tests](#running-non-app-module-tests)
+- [Next Steps](#next-steps)
+- [Troubleshooting Installation](#troubleshooting-installation)
 
 ## Prepare developer environment
 
-1. Download/Install [Android Studio Bumblebee | Patch 3](https://developer.android.com/studio/archive).
+1. Download and install Android Studio **Giraffe** from [this location](https://developer.android.com/studio/archive).
+   **Note**: You may try newer or older versions of Android Studio, but we can't guarantee good support.
path: wiki/Installing-Oppia-Android.md
user: login: TanishMoral11
body: ```suggestion
   **Note**: You may try newer or older versions of Android Studio, but we can't guarantee good support due to potential compatibility issues with different versions.
```



created_at: 2025-03-26T17:18:58Z
author_association: CONTRIBUTOR
diff_hunk: @@ -40,20 +330,17 @@ Please follow these steps to set up Oppia Android on your local machine.
 
    **Note**: Please keep the folder name as `oppia-android`. Changing the project folder name might lead to future issues with running the pre-push checks on your machine.
 
-2. Run the `bash scripts/setup.sh` script, which adds some development tools for Oppia Android (ktlint, checkstyle, etc.): These tools perform pre-push checks to ensure that your code is properly formatted as per Oppia standards.
+2. Run the `bash scripts/setup.sh` script, which adds some development tools for Oppia Android (ktlint, checkstyle, etc.). You should see a message indicating that the various tools have been downloaded.
 
path: wiki/Installing-Oppia-Android.md
user: login: TanishMoral11
body: ```suggestion
   **Troubleshooting**: If the `setup.sh` script fails, it could be due to missing dependencies (e.g., Git or Bash) or insufficient permissions. To resolve permission issues, run `chmod +x scripts/setup.sh` to make the script executable, then try running it again. If the issue persists, ensure all required tools are installed (e.g., via `sudo apt install git` on Linux or `brew install git` on Mac) and check the terminal output for specific error messages.

```
created_at: 2025-03-26T17:35:37Z
author_association: CONTRIBUTOR
diff_hunk: @@ -5,32 +5,322 @@ This wiki page explains how to install Oppia Android on your local machine. If y
 ## Table of Contents
 
 - [Prepare developer environment](#prepare-developer-environment)
+- [Install Bazel](#install-bazel)
+  - [Bazel Set up for Mac](#bazel-set-up-for-mac)
+  - [Bazel Set up for Linux](#bazel-set-up-for-linux)
+  - [Bazel Set up for Windows](#bazel-set-up-for-windows)
 - [Install oppia-android](#install-oppia-android)
-- [Run the app from Android Studio](#run-the-app-from-android-studio)
+- [Opening the Project in Android Studio](#opening-the-project-in-android-studio)
 - [Set up and Run tests](#set-up-and-run-tests)
-  - [Step-by-Step guidance for setting up and running app modules robolectric test](#step-by-step-guidance-for-setting-up-and-running-app-modules-robolectric-test)
-  - [For tests that are in non-app modules, such as **domain** or **utility**:](#for-tests-that-are-in-non-app-modules-such-as-domain-or-utility)
-
+  - [Running app module tests](#running-app-module-tests)
+  - [Running non-app module tests](#running-non-app-module-tests)
+- [Next Steps](#next-steps)
+- [Troubleshooting Installation](#troubleshooting-installation)
 
 ## Prepare developer environment
 
-1. Download/Install [Android Studio Bumblebee | Patch 3](https://developer.android.com/studio/archive).
+1. Download and install Android Studio **Giraffe** from [this location](https://developer.android.com/studio/archive).
+   **Note**: You may try newer or older versions of Android Studio, but we can't guarantee good support.
 
-   **Note**: We recommend installing **Android Studio Bumblebee | 2021.1.1 Patch 3** because newer versions of Android Studio[ do not support running tests where shared source sets are used](https://issuetracker.google.com/issues/232007221#comment18), a configuration we use at Oppia.
+2. Configure your Android Studio
+   - From your PC's application menu, open Android Studio. 
+   - On the welcome screen, find the "more options menu" and select **SDK Manager**
+     
+     <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/efcc4e6e-b6ba-44fc-9c96-aa381de83911" />
+    
+   - In the "SDK Platforms" tab (which is the default), select `API Level 30` and also `API Level 34`.
+   - Also, navigate to the "SDK Tools" tab, click the "Show Package Details" checkbox at the bottom right, then click on "Android SDK Build-Tools 34-rc1" and select 32.0.0 (this is needed for Bazel support).
 
-   **Direct download Url**: [Windows](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-windows.exe) | [Linux](https://redirector.gvt1.com/edgedl/android/studio/ide-zips/2021.1.1.23/android-studio-2021.1.1.23-linux.tar.gz) | [Intel Mac](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-mac.dmg) | [Apple Silicon Mac](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-mac_arm.dmg)
+   - Then, click "Apply" to download and install these two SDKs/Tools.
+     - On this screen, note the **Android SDK Location**, which is set as the ANDROID_HOME variable in the Bazel setup step below.
 
-   You can have multiple versions of Android Studio installed on your machine at the same time.
+3. Prepare a test device
+   You require a physical Android device or an Android emulator to run the Oppia app. 
+   - Physical devices are useful for a real-user experience feel, and testing with [accessibility tools](https://github.com/oppia/oppia-android/wiki/Accessibility-A11y-Guide#setting-up-accessibility-scanner-and-talkback).
+   
+     **Set up a physical device for development**
+      - On the device, open the **Settings** app, select **Developer options**, and then **enable USB debugging** (if applicable).
+        - If you don't see **Developer options**, you might need to enable developer mode first. Follow [these instructions](https://developer.android.com/studio/debug/dev-options#enable) to do so.
+        - Connect to your device using USB.
+        - Verify that your device is connected by running the `adb devices` command from your terminal.
+   
+      - Emulators provide the flexibility of testing the application on a variety of devices and Android API levels without needing to have each physical device.
+   
+     **Set up an Emulator**
+      - For the best experience, you should use the emulator in Android Studio on a computer with at least the following specs:
+        - 16 GB RAM
+        - 64-bit Windows 10 or higher, MacOS 12 or higher, Linux, or ChromeOS operating system
+        - 16 GB disk space
+     
+      - If you don't have these specs, the emulator might still run but not smoothly. In this case, consider testing on a physical device.
 
-2. Configure your Android Studio
-   - In Android Studio, open Tools > SDK Manager.
-     - In the "SDK Platforms" tab (which is the default), select `API Level 28` and also `API Level 30` (for Bazel support).
-     - Also, navigate to the "SDK Tools" tab, click the "Show Package Details" checkbox at the bottom right, then click on "Android SDK Build-Tools 34-rc1" and select 32.0.0 (this is needed for Bazel support).
+      - On the welcome screen, find the "more options menu" and select **Virtual Device Manager**
+     
+        <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/efcc4e6e-b6ba-44fc-9c96-aa381de83911" />
+         
+        * If you already have a project open in Android Studio, in the right hand toolbar, locate `device Manager`.
+      - Click the **+**, and then click **Create Virtual Device**.
+      - Follow the wizard to create a phone and a tablet AVD, setting the **system image** to be one of `API Level 30` or `API Level 34` as installed above.
+      - After creating your devices, you will be able to see a list of all the devices on the device manager panel.
+      - For more information on the different configurations available for AVDs, please visit the [official documentation page.](https://developer.android.com/studio/run/managing-avds)
 
-   - Then, click "Apply" to download and install these two SDKs/Tools.
+## Install Bazel
+### Instructions
+
+**The steps to setting up Bazel are:**
+1. Install Bazel
+2. Set Bazel and ANDROID_HOME paths permanently in your terminal
+3. Verify that the build is working
+
+The expected output of `bazel --version` once Bazel set up is successful is:
+
+```
+bazel 6.5.0
+```
+
+### Bazel Set up for Mac
+It is recommended to use the binary installer steps outline below. For other ways to install Bazel on Mac, refer to the [official page](https://bazel.build/install/os-x).
+
+**Step 1: Install Xcode command line tools**
+
+In macOS 14 or earlier, it is sufficient to install the Xcode command line tools package by using xcode-select:
+
+```
+xcode-select --install
+```
+
+Otherwise, for macOS 15 and later, you must have Xcode 6.1 or later installed on your system.
+
+Download Xcode from the [App Store](https://apps.apple.com/us/app/xcode/id497799835) or the [Apple Developer site](https://developer.apple.com/download/more/?=xcode).
+
+Once Xcode is installed, accept the license agreement for all users with the following command:
+
+```
+sudo xcodebuild -license accept
+```
+
+**Step 2: Download the Bazel installer**
+
+Click [here](https://github.com/bazelbuild/bazel/releases/download/6.5.0/bazel-6.5.0-installer-darwin-x86_64.sh) to download the Bazel 6.5.0 binary installer.
+
+**Step 3: Run the installer**
+
+Run the Bazel installer as follows:
+
+```shell
+chmod +x "bazel-6.5.0-installer-darwin-x86_64.sh"
+./bazel-6.5.0-installer-darwin-x86_64.sh --user
+```
+
+**Step 4: Set up your environment**
+
+You must set the path for `Bazel` and `ANDROID_HOME` before running bazel build for oppia-android, otherwise you will get an error.
+
+If you ran the Bazel installer with the `--user` flag as above, the Bazel executable is installed in your $HOME/bin directory. It’s a good idea to add this directory to your default paths, as follows:
+
+```shell
+export PATH="$PATH:$HOME/bin"
+```
+
+To set the `ANDROID_HOME` path permanently in your terminal run these commands:
+
+```
+sudo nano /etc/paths
+```
+- Enter your password, when prompted.
+- Go to the bottom of the file, and enter this path: `$HOME/Library/Android/sdk`
+- Hit control-x to quit.
+- Enter “Y” to save the modified buffer.
+- That’s it! To test it, in a new terminal window, type: `echo $PATH`
+
+**Step 5: Verify that the build is working**
+
+Run the following command in your terminal:
+
+```
+bazel --version
+```
+
+### Bazel Set up for Linux
+This section covers Bazel installation on Ubuntu. 
+
+Recommendations:
+- use Ubuntu 18.04 (LTS), 20.04 (LTS), or 22.04 (LTS).
+- use ``apt`` installation instructions.
+
+- **Note**: if you encounter any errors related to `cURL`, please set up cURL on your machine using `sudo apt install curl`.
+
+**Step 1: Add Bazel distribution URI as a package source**
+
+This is a one-time setup step.
+
+```
+sudo apt install apt-transport-https curl gnupg -y
+curl -fsSL https://bazel.build/bazel-release.pub.gpg | gpg --dearmor >bazel-archive-keyring.gpg
+sudo mv bazel-archive-keyring.gpg /usr/share/keyrings
+echo "deb [arch=amd64 signed-by=/usr/share/keyrings/bazel-archive-keyring.gpg] https://storage.googleapis.com/bazel-apt stable jdk1.8" | sudo tee /etc/apt/sources.list.d/bazel.list
+```
+
+**Step 2: Install and update Bazel**
+
+Run:
+```shell
+sudo apt-get update && sudo apt-get install bazel-6.5.0
+```
+
+**Step 3: Set up your environment**
+
+Ensure that your `ANDROID_HOME` environment variable is set to the location of your Android SDK. Assuming the SDK is installed to default locations, you can use the following commands to set the `ANDROID_HOME` variable:
+
+```
+export ANDROID_HOME=$HOME/Android/Sdk/
+```
+
+**Step 4: Verify that the build is working**
+
+Run the following command in your terminal:
+
+```
+bazel --version
+```
+
+### Bazel Set up for Windows
+This page outlines one way to allow Bazel to be used in CLI form on Windows. Please note that **this support is currently experimental**. We suggest that you post a discussion at [github-discussions](https://github.com/oppia/oppia-android/discussions/categories/q-a-installation) if you run into any problems.
+
+Unlike Unix-based systems where Bazel runs natively without issue, the current solution on Windows is to install an Ubuntu-based subsystem. Windows currently only supports a terminal experience in this subsystem (though there is a prerelease version of the software with GUI support) which means Android Studio will not be supported. You will need to continue using the Windows version of Android Studio and only use the Linux subsystem for building & running Robolectric or JUnit-based tests.
+
+Due to the issues mentioned above, we recommend dual-booting your PC with Linux. However, if you choose to use Windows, please follow the instructions below:
path: wiki/Installing-Oppia-Android.md
user: login: TanishMoral11
body: ```suggestion
Due to the issues mentioned above, we recommend dual-booting your PC with Linux for a smoother experience (e.g., better performance and native Bazel support). If you prefer to use Windows, please follow the instructions below:
```
created_at: 2025-03-26T17:43:22Z
author_association: CONTRIBUTOR
diff_hunk: @@ -0,0 +1,284 @@
+## Table of Contents
+
+- [Overview](#overview)
+- [Installation](#installation)
+  - [Building the app](#building-the-app)
+- [Running Tests](#running-tests)
+  - [How to Obtain a Test Target](#how-to-obtain-a-test-target)
+  - [Common Flags](#common-flags)
+  - [Running multiple test targets](#running-multiple-test-targets)
+- [Concepts and Terminology](#concepts-and-terminology)
+- [Syncing the Project](#syncing-the-project)
+
+## Overview
+Bazel is an open-source build and test tool similar to Make, Maven, and Gradle. It uses a human-readable, high-level build language.
path: wiki/Bazel-User-Guide.md
user: login: TanishMoral11
body: ```suggestion
Bazel is an open-source build and test tool similar to Make, Maven, and Gradle. It uses a human-readable, high-level build language. Oppia Android uses Bazel for its fast, scalable builds and consistent results across different environments, making it ideal for large projects like Oppia.
```
created_at: 2025-03-26T17:49:53Z
author_association: CONTRIBUTOR
diff_hunk: @@ -5,32 +5,322 @@ This wiki page explains how to install Oppia Android on your local machine. If y
 ## Table of Contents
 
 - [Prepare developer environment](#prepare-developer-environment)
+- [Install Bazel](#install-bazel)
+  - [Bazel Set up for Mac](#bazel-set-up-for-mac)
+  - [Bazel Set up for Linux](#bazel-set-up-for-linux)
+  - [Bazel Set up for Windows](#bazel-set-up-for-windows)
 - [Install oppia-android](#install-oppia-android)
-- [Run the app from Android Studio](#run-the-app-from-android-studio)
+- [Opening the Project in Android Studio](#opening-the-project-in-android-studio)
 - [Set up and Run tests](#set-up-and-run-tests)
-  - [Step-by-Step guidance for setting up and running app modules robolectric test](#step-by-step-guidance-for-setting-up-and-running-app-modules-robolectric-test)
-  - [For tests that are in non-app modules, such as **domain** or **utility**:](#for-tests-that-are-in-non-app-modules-such-as-domain-or-utility)
-
+  - [Running app module tests](#running-app-module-tests)
+  - [Running non-app module tests](#running-non-app-module-tests)
+- [Next Steps](#next-steps)
+- [Troubleshooting Installation](#troubleshooting-installation)
 
 ## Prepare developer environment
 
-1. Download/Install [Android Studio Bumblebee | Patch 3](https://developer.android.com/studio/archive).
+1. Download and install Android Studio **Giraffe** from [this location](https://developer.android.com/studio/archive).
+   **Note**: You may try newer or older versions of Android Studio, but we can't guarantee good support.
path: wiki/Installing-Oppia-Android.md
user: login: TanishMoral11
body: The original note warns about support but doesn’t explain why Giraffe is preferred. Adding this detail helps new contributors understand that Giraffe is the tested, reliable choice, reducing setup confusion and potential issues. It’s a small tweak that makes the guide more welcoming and clear for beginners.
created_at: 2025-03-26T18:04:15Z
author_association: CONTRIBUTOR
diff_hunk: @@ -40,20 +330,17 @@ Please follow these steps to set up Oppia Android on your local machine.
 
    **Note**: Please keep the folder name as `oppia-android`. Changing the project folder name might lead to future issues with running the pre-push checks on your machine.
 
-2. Run the `bash scripts/setup.sh` script, which adds some development tools for Oppia Android (ktlint, checkstyle, etc.): These tools perform pre-push checks to ensure that your code is properly formatted as per Oppia standards.
+2. Run the `bash scripts/setup.sh` script, which adds some development tools for Oppia Android (ktlint, checkstyle, etc.). You should see a message indicating that the various tools have been downloaded.
 
path: wiki/Installing-Oppia-Android.md
user: login: TanishMoral11
body: The current text assumes the script runs perfectly, but new contributors might hit issues like permission errors or missing Git. Adding this troubleshooting note provides clear, immediate steps to fix common problems, making setup easier and less frustrating. It’s especially helpful for beginners who may not know how to debug script failures.
created_at: 2025-03-26T18:04:55Z
author_association: CONTRIBUTOR
diff_hunk: @@ -0,0 +1,284 @@
+## Table of Contents
+
+- [Overview](#overview)
+- [Installation](#installation)
+  - [Building the app](#building-the-app)
+- [Running Tests](#running-tests)
+  - [How to Obtain a Test Target](#how-to-obtain-a-test-target)
+  - [Common Flags](#common-flags)
+  - [Running multiple test targets](#running-multiple-test-targets)
+- [Concepts and Terminology](#concepts-and-terminology)
+- [Syncing the Project](#syncing-the-project)
+
+## Overview
+Bazel is an open-source build and test tool similar to Make, Maven, and Gradle. It uses a human-readable, high-level build language.
+
+## Installation
+
+Follow the instructions on the [installation page](https://github.com/oppia/oppia-android/wiki/Installing-Oppia-Android#install-bazel) to set up Bazel.
+
+### Building the app
+
+The [installation page](https://github.com/oppia/oppia-android/wiki/Installing-Oppia-Android#install-bazel) provides information on running the project in Android Studio.
+
+You can also run the app from the command line using the commands detailed below.
+
+Using the command line is helpful in instances when you need to build and run some targets outside of Android Studio.
+
+Run the following commands in your terminal. All Bazel commands must be run from the root of the `oppia-android` directory otherwise they will fail.
+
+Note that on the first run, these commands may take 10-20 minutes to complete depending on the performance of your machine. Subsequent runs will be much faster.
+
+**On SDK 29 and below, run**:
+   ```
+   bazel mobile-install //:oppia_dev_binary
+   ```
+This will build, install and launch the app on your device.
+
+**On SDK 30 and newer, run**:
+   ```
+   bazel build //:oppia_dev
+   ```
+followed by:
+   ```
+   adb install bazel-bin/oppia_dev_binary.apk  
+   ```
+* Starting from SDK 30, incremental builds, like those executed using `bazel mobile-install`, are no longer permitted, necessitating the use of two separate commands.
+
+If everything is working, you should see output like the following:
+
+```
+Target //:oppia_dev_binary up-to-date:
+  bazel-bin/oppia_dev_binary_deploy.jar
+  bazel-bin/oppia_dev_binary_unsigned.apk
+  bazel-bin/oppia_dev_binary.apk
+INFO: Elapsed time: 37.155s, Critical Path: 17.24s
+INFO: 99 processes: 2 internal, 23 darwin-sandbox, 74 worker.
+INFO: Build completed successfully, 99 total actions
+Performing Streamed Install
+Success
+```
+
+Note also that the ``oppia_dev.aab`` under the ``bazel-bin`` directory of your local copy of Oppia Android should be a fully functioning development version of the app that can be installed using bundle-tool. However, it's recommended to deploy Oppia to an emulator or connected device using the `mobile-install` command.
+
+## Running Tests
+
+The bazel test command is used to build and run tests in a Bazel workspace. It ensures that the specified test targets are built and executed in a sandboxed environment for reproducibility.
+
+**Syntax**
+
+```shell
+bazel test //path/to:target
+```
+
+### How to Obtain a Test Target
+A test target in Bazel refers to a specific testable entity defined in a BUILD file. It represents a test rule, such as `java_test` or `android_test`, that Bazel can build and execute.
+
+To ensure you always use the correct test target, follow one of these steps:
+1. If the test file is open in Android Studio:
+   * Right-click to open the context menu and select **Copy BUILD target string** as shown.
+     
+     ![Screenshot 2025-03-18 at 22 30 22](https://github.com/user-attachments/assets/286ebcb6-4f4e-4055-b6f0-4c070b039375)
+   
+   * Paste the target to the bazel test command, e.g. `bazel test //domain/src/test/java/org/oppia/android/domain/onboarding:AppStartupStateControllerTest`
+
+2. If the test file is open in Android Studio, but **Copy BUILD target string** is not available in the context menu:
+Sometimes the **Copy BUILD target string** is not available in the context menu either due to sync issues or modularization issues. You can still copy the file path, and pass it to the test command.
+   * In the AS sidebar, right click on the file, and select `copy path/reference`.
+     or
+   * Right-click on the file tab and then click `copy path/reference`.
+   * Next, select `copy path from repository root`. 
+   * Paste the copied path to the bazel test command in the terminal and remove the `.kt` extension, e.g. `bazel test domain/src/test/java/org/oppia/android/domain/onboarding/AppStartupStateControllerTest`.
+
+With this syntax, Bazel implicitly converts the file path into a target if it matches a test rule in the BUILD file. If the file is not part of a test target in the BUILD file, this command may fail.
+**When to use this**: If you are unsure about the exact Bazel target and want a quick way to run a test.
+
+3. Querying for a target
+Using the explicit Bazel target (// syntax) is more reliable compared to the file path syntax above. However, in cases such as running the test outside android studio, you may not know the target. In this case, you can use Bazel's `query` command to retrieve the correct test target:
+   * Copy the relative path of the test file.
+   * Run the following command in your terminal to get the test’s Bazel target: `bazel query relative-path-of-test-file`
+   Example
+   
+   ```shell
+   bazel query domain/src/test/java/org/oppia/android/domain/onboarding/AppStartupStateControllerTest.kt
+   ```
+   * The output will be a Bazel target that starts with //. Copy the target and remove the .kt extension.
+   * Use this target in the bazel test command, e.g. `bazel test //domain/src/test/java/org/oppia/android/domain/onboarding:AppStartupStateControllerTest`.
+
+### Common Flags
+
+`--test_output=all` → Show full test output.
+`--cache_test_results=no` → Force re-running tests even if cached.
+`--test_filter=ClassName#methodName` → Run specific test cases.
+`--runs_per_test=100` → Specifies number of times to run each test.
+
+### Running multiple test targets
+To run all the test targets in the app module:
+
+```
+bazel test //app/...
+```
+
+To run all the test targets in the project (note that this would be extremely slow and is not recommended):
+
+```
+bazel test //...
+```
+
+To run multiple test targets at once:
+
+```
+bazel test -- //path/to/target/FirstTest //path/to/target/SecondTest
+```
+
+## Concepts and Terminology
+**[Workspace](https://github.com/oppia/oppia-android/blob/7344270032ac242b1b8987f1b51c8b5aa4f14ce3/WORKSPACE#L2)**
+
+A workspace is a directory where we specify the targeted SDK version, required dependencies, and corresponding Rules. The directory containing the WORKSPACE file is the root of the main repository, which in our case, is the `oppia-android` root directory.
+**[Packages](https://github.com/oppia/oppia-android/tree/develop/app)**
+
+A package is defined as a directory containing a file named BUILD or BUILD.bazel.
+
+**[Binary rules](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/BUILD.bazel#L3)**
+
+A rule specifies the relationship between inputs and outputs, and the steps to build the outputs.
+In Android, rules are defined using `android_binary`. Android rules for testing are `android_instrumentation_test` and `android_local_test`.
+
+**[BUILD files](https://github.com/oppia/oppia-android/blob/7344270032ac242b1b8987f1b51c8b5aa4f14ce3/app/BUILD.bazel#L3)**
+
+Every package contains a BUILD file. This file is written in Starlark Language. In this Build file for module-level, we generally define `android_library`, `kt_android_library` to build our package files as per the requirement.
+
+**[Dependencies](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/BUILD.bazel#L16)**
+
+A target A depends upon a target B if B is needed by A at build. `A -> B`
+
+```
+deps = [ "//app",]
+```
+Here, `deps` is used to define the dependencies which is a type of dependencies called `deps dependencies` and it includes the files/directory/target which are dependent. From the above example the dependency is the `app` target which is defined in the [Build file of app package](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/app/BUILD.bazel#L616).
path: wiki/Bazel-User-Guide.md
user: login: adhiamboperes
body: Done
created_at: 2025-03-26T22:43:55Z
author_association: CONTRIBUTOR
diff_hunk: @@ -0,0 +1,284 @@
+## Table of Contents
+
+- [Overview](#overview)
+- [Installation](#installation)
+  - [Building the app](#building-the-app)
+- [Running Tests](#running-tests)
+  - [How to Obtain a Test Target](#how-to-obtain-a-test-target)
+  - [Common Flags](#common-flags)
+  - [Running multiple test targets](#running-multiple-test-targets)
+- [Concepts and Terminology](#concepts-and-terminology)
+- [Syncing the Project](#syncing-the-project)
+
+## Overview
+Bazel is an open-source build and test tool similar to Make, Maven, and Gradle. It uses a human-readable, high-level build language.
+
+## Installation
+
+Follow the instructions on the [installation page](https://github.com/oppia/oppia-android/wiki/Installing-Oppia-Android#install-bazel) to set up Bazel.
+
+### Building the app
+
+The [installation page](https://github.com/oppia/oppia-android/wiki/Installing-Oppia-Android#install-bazel) provides information on running the project in Android Studio.
+
+You can also run the app from the command line using the commands detailed below.
+
+Using the command line is helpful in instances when you need to build and run some targets outside of Android Studio.
+
+Run the following commands in your terminal. All Bazel commands must be run from the root of the `oppia-android` directory otherwise they will fail.
+
+Note that on the first run, these commands may take 10-20 minutes to complete depending on the performance of your machine. Subsequent runs will be much faster.
+
+**On SDK 29 and below, run**:
+   ```
+   bazel mobile-install //:oppia_dev_binary
+   ```
+This will build, install and launch the app on your device.
+
+**On SDK 30 and newer, run**:
+   ```
+   bazel build //:oppia_dev
+   ```
+followed by:
+   ```
+   adb install bazel-bin/oppia_dev_binary.apk  
+   ```
+* Starting from SDK 30, incremental builds, like those executed using `bazel mobile-install`, are no longer permitted, necessitating the use of two separate commands.
+
+If everything is working, you should see output like the following:
+
+```
+Target //:oppia_dev_binary up-to-date:
+  bazel-bin/oppia_dev_binary_deploy.jar
+  bazel-bin/oppia_dev_binary_unsigned.apk
+  bazel-bin/oppia_dev_binary.apk
+INFO: Elapsed time: 37.155s, Critical Path: 17.24s
+INFO: 99 processes: 2 internal, 23 darwin-sandbox, 74 worker.
+INFO: Build completed successfully, 99 total actions
+Performing Streamed Install
+Success
+```
+
+Note also that the ``oppia_dev.aab`` under the ``bazel-bin`` directory of your local copy of Oppia Android should be a fully functioning development version of the app that can be installed using bundle-tool. However, it's recommended to deploy Oppia to an emulator or connected device using the `mobile-install` command.
+
+## Running Tests
+
+The bazel test command is used to build and run tests in a Bazel workspace. It ensures that the specified test targets are built and executed in a sandboxed environment for reproducibility.
+
+**Syntax**
+
+```shell
+bazel test //path/to:target
+```
+
+### How to Obtain a Test Target
+A test target in Bazel refers to a specific testable entity defined in a BUILD file. It represents a test rule, such as `java_test` or `android_test`, that Bazel can build and execute.
+
+To ensure you always use the correct test target, follow one of these steps:
+1. If the test file is open in Android Studio:
+   * Right-click to open the context menu and select **Copy BUILD target string** as shown.
+     
+     ![Screenshot 2025-03-18 at 22 30 22](https://github.com/user-attachments/assets/286ebcb6-4f4e-4055-b6f0-4c070b039375)
+   
+   * Paste the target to the bazel test command, e.g. `bazel test //domain/src/test/java/org/oppia/android/domain/onboarding:AppStartupStateControllerTest`
+
+2. If the test file is open in Android Studio, but **Copy BUILD target string** is not available in the context menu:
+Sometimes the **Copy BUILD target string** is not available in the context menu either due to sync issues or modularization issues. You can still copy the file path, and pass it to the test command.
+   * In the AS sidebar, right click on the file, and select `copy path/reference`.
+     or
+   * Right-click on the file tab and then click `copy path/reference`.
+   * Next, select `copy path from repository root`. 
+   * Paste the copied path to the bazel test command in the terminal and remove the `.kt` extension, e.g. `bazel test domain/src/test/java/org/oppia/android/domain/onboarding/AppStartupStateControllerTest`.
+
+With this syntax, Bazel implicitly converts the file path into a target if it matches a test rule in the BUILD file. If the file is not part of a test target in the BUILD file, this command may fail.
+**When to use this**: If you are unsure about the exact Bazel target and want a quick way to run a test.
+
+3. Querying for a target
+Using the explicit Bazel target (// syntax) is more reliable compared to the file path syntax above. However, in cases such as running the test outside android studio, you may not know the target. In this case, you can use Bazel's `query` command to retrieve the correct test target:
+   * Copy the relative path of the test file.
+   * Run the following command in your terminal to get the test’s Bazel target: `bazel query relative-path-of-test-file`
+   Example
+   
+   ```shell
+   bazel query domain/src/test/java/org/oppia/android/domain/onboarding/AppStartupStateControllerTest.kt
+   ```
+   * The output will be a Bazel target that starts with //. Copy the target and remove the .kt extension.
+   * Use this target in the bazel test command, e.g. `bazel test //domain/src/test/java/org/oppia/android/domain/onboarding:AppStartupStateControllerTest`.
+
+### Common Flags
+
+`--test_output=all` → Show full test output.
+`--cache_test_results=no` → Force re-running tests even if cached.
+`--test_filter=ClassName#methodName` → Run specific test cases.
+`--runs_per_test=100` → Specifies number of times to run each test.
+
+### Running multiple test targets
+To run all the test targets in the app module:
+
+```
+bazel test //app/...
+```
+
+To run all the test targets in the project (note that this would be extremely slow and is not recommended):
+
+```
+bazel test //...
+```
+
+To run multiple test targets at once:
+
+```
+bazel test -- //path/to/target/FirstTest //path/to/target/SecondTest
+```
+
+## Concepts and Terminology
+**[Workspace](https://github.com/oppia/oppia-android/blob/7344270032ac242b1b8987f1b51c8b5aa4f14ce3/WORKSPACE#L2)**
+
+A workspace is a directory where we specify the targeted SDK version, required dependencies, and corresponding Rules. The directory containing the WORKSPACE file is the root of the main repository, which in our case, is the `oppia-android` root directory.
+**[Packages](https://github.com/oppia/oppia-android/tree/develop/app)**
+
+A package is defined as a directory containing a file named BUILD or BUILD.bazel.
+
+**[Binary rules](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/BUILD.bazel#L3)**
+
+A rule specifies the relationship between inputs and outputs, and the steps to build the outputs.
+In Android, rules are defined using `android_binary`. Android rules for testing are `android_instrumentation_test` and `android_local_test`.
+
+**[BUILD files](https://github.com/oppia/oppia-android/blob/7344270032ac242b1b8987f1b51c8b5aa4f14ce3/app/BUILD.bazel#L3)**
+
+Every package contains a BUILD file. This file is written in Starlark Language. In this Build file for module-level, we generally define `android_library`, `kt_android_library` to build our package files as per the requirement.
+
+**[Dependencies](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/BUILD.bazel#L16)**
+
+A target A depends upon a target B if B is needed by A at build. `A -> B`
+
+```
+deps = [ "//app",]
+```
+Here, `deps` is used to define the dependencies which is a type of dependencies called `deps dependencies` and it includes the files/directory/target which are dependent. From the above example the dependency is the `app` target which is defined in the [Build file of app package](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/app/BUILD.bazel#L616).
+
+Example of Dependencies
+1. [srcs dependencies](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/app/BUILD.bazel#L617)
+2. [deps dependencies](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/app/BUILD.bazel#L622)
+
+**[Loading an extension](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/app/BUILD.bazel#L13)**
+
+Bazel extensions are files ending in .bzl. Use the load statement to import a symbol from an extension.
+
+```
+load("@io_bazel_rules_kotlin//kotlin:android.bzl", "kt_android_library")
+```
+Here, we are loading `android.bzl` and we are going to use it with a symbol name `kt_android_library`.
+Arguments to the load function must be string literals. load statements must appear at top-level in the file.
+
+**[Visibility of a file target](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/app/BUILD.bazel#L621)**
+
+With the example from our codebase, target `app` whose visibility is public. 
+
+ - `visibility = ["//visibility:public"],` - Anyone can use this target.
+ - `"//visibility:private"` - Only targets in this package can use this target.
+
+**[Testing](https://github.com/oppia/oppia-android/blob/7344270032ac242b1b8987f1b51c8b5aa4f14ce3/app/src/sharedTest/java/org/oppia/android/app/player/exploration/BUILD.bazel#L7)**
+
+when we want to run test cases on Bazel build environment, a test target needs to be set up correctly:
path: wiki/Bazel-User-Guide.md
user: login: adhiamboperes
body: Done
created_at: 2025-03-26T22:44:26Z
author_association: CONTRIBUTOR
diff_hunk: @@ -0,0 +1,284 @@
+## Table of Contents
+
+- [Overview](#overview)
+- [Installation](#installation)
+  - [Building the app](#building-the-app)
+- [Running Tests](#running-tests)
+  - [How to Obtain a Test Target](#how-to-obtain-a-test-target)
+  - [Common Flags](#common-flags)
+  - [Running multiple test targets](#running-multiple-test-targets)
+- [Concepts and Terminology](#concepts-and-terminology)
+- [Syncing the Project](#syncing-the-project)
+
+## Overview
+Bazel is an open-source build and test tool similar to Make, Maven, and Gradle. It uses a human-readable, high-level build language.
+
+## Installation
+
+Follow the instructions on the [installation page](https://github.com/oppia/oppia-android/wiki/Installing-Oppia-Android#install-bazel) to set up Bazel.
+
+### Building the app
+
+The [installation page](https://github.com/oppia/oppia-android/wiki/Installing-Oppia-Android#install-bazel) provides information on running the project in Android Studio.
+
+You can also run the app from the command line using the commands detailed below.
+
+Using the command line is helpful in instances when you need to build and run some targets outside of Android Studio.
+
+Run the following commands in your terminal. All Bazel commands must be run from the root of the `oppia-android` directory otherwise they will fail.
+
+Note that on the first run, these commands may take 10-20 minutes to complete depending on the performance of your machine. Subsequent runs will be much faster.
+
+**On SDK 29 and below, run**:
+   ```
+   bazel mobile-install //:oppia_dev_binary
+   ```
+This will build, install and launch the app on your device.
+
+**On SDK 30 and newer, run**:
+   ```
+   bazel build //:oppia_dev
+   ```
+followed by:
+   ```
+   adb install bazel-bin/oppia_dev_binary.apk  
+   ```
+* Starting from SDK 30, incremental builds, like those executed using `bazel mobile-install`, are no longer permitted, necessitating the use of two separate commands.
+
+If everything is working, you should see output like the following:
+
+```
+Target //:oppia_dev_binary up-to-date:
+  bazel-bin/oppia_dev_binary_deploy.jar
+  bazel-bin/oppia_dev_binary_unsigned.apk
+  bazel-bin/oppia_dev_binary.apk
+INFO: Elapsed time: 37.155s, Critical Path: 17.24s
+INFO: 99 processes: 2 internal, 23 darwin-sandbox, 74 worker.
+INFO: Build completed successfully, 99 total actions
+Performing Streamed Install
+Success
+```
+
+Note also that the ``oppia_dev.aab`` under the ``bazel-bin`` directory of your local copy of Oppia Android should be a fully functioning development version of the app that can be installed using bundle-tool. However, it's recommended to deploy Oppia to an emulator or connected device using the `mobile-install` command.
+
+## Running Tests
+
+The bazel test command is used to build and run tests in a Bazel workspace. It ensures that the specified test targets are built and executed in a sandboxed environment for reproducibility.
+
+**Syntax**
+
+```shell
+bazel test //path/to:target
+```
+
+### How to Obtain a Test Target
+A test target in Bazel refers to a specific testable entity defined in a BUILD file. It represents a test rule, such as `java_test` or `android_test`, that Bazel can build and execute.
+
+To ensure you always use the correct test target, follow one of these steps:
+1. If the test file is open in Android Studio:
+   * Right-click to open the context menu and select **Copy BUILD target string** as shown.
+     
+     ![Screenshot 2025-03-18 at 22 30 22](https://github.com/user-attachments/assets/286ebcb6-4f4e-4055-b6f0-4c070b039375)
+   
+   * Paste the target to the bazel test command, e.g. `bazel test //domain/src/test/java/org/oppia/android/domain/onboarding:AppStartupStateControllerTest`
+
+2. If the test file is open in Android Studio, but **Copy BUILD target string** is not available in the context menu:
+Sometimes the **Copy BUILD target string** is not available in the context menu either due to sync issues or modularization issues. You can still copy the file path, and pass it to the test command.
+   * In the AS sidebar, right click on the file, and select `copy path/reference`.
+     or
+   * Right-click on the file tab and then click `copy path/reference`.
+   * Next, select `copy path from repository root`. 
+   * Paste the copied path to the bazel test command in the terminal and remove the `.kt` extension, e.g. `bazel test domain/src/test/java/org/oppia/android/domain/onboarding/AppStartupStateControllerTest`.
+
+With this syntax, Bazel implicitly converts the file path into a target if it matches a test rule in the BUILD file. If the file is not part of a test target in the BUILD file, this command may fail.
+**When to use this**: If you are unsure about the exact Bazel target and want a quick way to run a test.
+
+3. Querying for a target
+Using the explicit Bazel target (// syntax) is more reliable compared to the file path syntax above. However, in cases such as running the test outside android studio, you may not know the target. In this case, you can use Bazel's `query` command to retrieve the correct test target:
+   * Copy the relative path of the test file.
+   * Run the following command in your terminal to get the test’s Bazel target: `bazel query relative-path-of-test-file`
+   Example
+   
+   ```shell
+   bazel query domain/src/test/java/org/oppia/android/domain/onboarding/AppStartupStateControllerTest.kt
+   ```
+   * The output will be a Bazel target that starts with //. Copy the target and remove the .kt extension.
+   * Use this target in the bazel test command, e.g. `bazel test //domain/src/test/java/org/oppia/android/domain/onboarding:AppStartupStateControllerTest`.
+
+### Common Flags
+
+`--test_output=all` → Show full test output.
+`--cache_test_results=no` → Force re-running tests even if cached.
+`--test_filter=ClassName#methodName` → Run specific test cases.
+`--runs_per_test=100` → Specifies number of times to run each test.
+
+### Running multiple test targets
+To run all the test targets in the app module:
+
+```
+bazel test //app/...
+```
+
+To run all the test targets in the project (note that this would be extremely slow and is not recommended):
+
+```
+bazel test //...
+```
+
+To run multiple test targets at once:
+
+```
+bazel test -- //path/to/target/FirstTest //path/to/target/SecondTest
+```
+
+## Concepts and Terminology
+**[Workspace](https://github.com/oppia/oppia-android/blob/7344270032ac242b1b8987f1b51c8b5aa4f14ce3/WORKSPACE#L2)**
+
+A workspace is a directory where we specify the targeted SDK version, required dependencies, and corresponding Rules. The directory containing the WORKSPACE file is the root of the main repository, which in our case, is the `oppia-android` root directory.
+**[Packages](https://github.com/oppia/oppia-android/tree/develop/app)**
+
+A package is defined as a directory containing a file named BUILD or BUILD.bazel.
+
+**[Binary rules](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/BUILD.bazel#L3)**
+
+A rule specifies the relationship between inputs and outputs, and the steps to build the outputs.
+In Android, rules are defined using `android_binary`. Android rules for testing are `android_instrumentation_test` and `android_local_test`.
+
+**[BUILD files](https://github.com/oppia/oppia-android/blob/7344270032ac242b1b8987f1b51c8b5aa4f14ce3/app/BUILD.bazel#L3)**
+
+Every package contains a BUILD file. This file is written in Starlark Language. In this Build file for module-level, we generally define `android_library`, `kt_android_library` to build our package files as per the requirement.
+
+**[Dependencies](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/BUILD.bazel#L16)**
+
+A target A depends upon a target B if B is needed by A at build. `A -> B`
+
+```
+deps = [ "//app",]
+```
+Here, `deps` is used to define the dependencies which is a type of dependencies called `deps dependencies` and it includes the files/directory/target which are dependent. From the above example the dependency is the `app` target which is defined in the [Build file of app package](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/app/BUILD.bazel#L616).
+
+Example of Dependencies
+1. [srcs dependencies](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/app/BUILD.bazel#L617)
+2. [deps dependencies](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/app/BUILD.bazel#L622)
+
+**[Loading an extension](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/app/BUILD.bazel#L13)**
+
+Bazel extensions are files ending in .bzl. Use the load statement to import a symbol from an extension.
+
+```
+load("@io_bazel_rules_kotlin//kotlin:android.bzl", "kt_android_library")
+```
+Here, we are loading `android.bzl` and we are going to use it with a symbol name `kt_android_library`.
+Arguments to the load function must be string literals. load statements must appear at top-level in the file.
+
+**[Visibility of a file target](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/app/BUILD.bazel#L621)**
+
+With the example from our codebase, target `app` whose visibility is public. 
+
+ - `visibility = ["//visibility:public"],` - Anyone can use this target.
+ - `"//visibility:private"` - Only targets in this package can use this target.
+
+**[Testing](https://github.com/oppia/oppia-android/blob/7344270032ac242b1b8987f1b51c8b5aa4f14ce3/app/src/sharedTest/java/org/oppia/android/app/player/exploration/BUILD.bazel#L7)**
+
+when we want to run test cases on Bazel build environment, a test target needs to be set up correctly:
+
+```bazel
+load("//:oppia_android_test.bzl", "oppia_android_test")
+
+oppia_android_test(
+    name = "MathExpressionInteractionsViewTest",
+    srcs = [
+        "MathExpressionInteractionsViewTest.kt",
+        "//app:data_binder_mapper_impl"
+    ],
+    custom_package = "org.oppia.android.app.test",
+    test_manifest = "//app:test_manifest",
+    enable_data_binding = True,
+    test_class = "org.oppia.android.app.customview.interaction.MathExpressionInteractionsViewTest",
+    deps = [
+      ...
+    ],
+)
+```
+
+The above assumes that the corresponding test requires resources. If it doesn't, the definition can be a bit simpler:
+
+```bazel
+load("//:oppia_android_test.bzl", "oppia_android_test")
+
+oppia_android_test(
+    name = "MathExpressionAccessibilityUtilTest",
+    srcs = ["MathExpressionAccessibilityUtilTest.kt"],
+    custom_package = "org.oppia.android.app.utility.math",
+    test_manifest = "//app:test_manifest",
+    test_class = "org.oppia.android.app.utility.math.MathExpressionAccessibilityUtilTest",
+    deps = [
+      ...
+    ],
+)
+```
+
+## Syncing the Project
+The IntelliJ Bazel Plugin's Sync process has a purpose to query Bazel for information and build up IntelliJ's project structure to fit Bazel's model.
+
+It runs automatically during a project import, and manually by either clicking on the sync icon in the menu bar or, partially syncing packages and individual files in contextual menus.
+
+Running a sync generates a `.aswb` directory in the project root. 
+
+### Structure of the .aswb
+The `.aswb` is known as the **project directory**. It contains metadata about the project that bridges Bazel and IntelliJ project models.
+```
+.aswb/
+├── .bazelproject
+├── .blaze
+│   ├── aar_libraries
+│   ├── modules
+│   ├── remoteOutputCache 
+│   └── renderjars
+└── .idea
+```
+
+The `.bazelproject` is the project view file which contains project-wide settings, like targets to sync, Bazel flags, and enabled languages. It is used to import a subset of Bazel packages into the IDE. The project view determines which rules are imported and how. Read more information [here](https://ij.bazel.build/docs/project-views.html).
+
+The `.blaze` is the Bazel data subdirectory, containing mostly IntelliJ module definitions. 
+  - `modules` directory contains IntelliJ module definition files.
+  - `remoteOutputCache` is a general-purpose local cache for output artifacts generated remotely. During a project sync, updated outputs of interest will be copied locally.
+  - `aar_libraries` is the location of the plugin's JAR cache. This helps provide a more robust code navigation experience, but with the possibility of missing changes made by Bazel outside of the IDE view.
+
+The `.idea` directory contains project-specific settings files managed by IntelliJ. IntelliJ reads XML files in this directory to set up the Project Structure: project, modules, libraries, SDKs, facets.
+
+### Syncing (and Partial Syncing) the Bazel Plugin in Android Studio
+When you make certain changes to your project files, you need to sync your project with Bazel to pick up those changes. For example:
+* Changing a BUILD file, like adding a new target, or adding dependencies and sources to a target.
+* Changing generated output files required to resolve source code, like annotation processor outputs such as AutoValue-generated classes.
+
+You can sync with Bazel in two ways:
+* From your IDE’s menu, click **Bazel > Sync > Sync Project with BUILD files.**
+* From the toolbar, click the **Sync Project with BUILD files** button.
+
+**Expand Sync to Working Set**
+
+Your working set is any files your VCS says are dirty, roughly corresponding to something like git status. By default the plugin tries to expand the sync to cover any target in your working set. This ensures these files are refreshed without having to go to the trouble of adding a temporary target to your project view.
path: wiki/Bazel-User-Guide.md
user: login: adhiamboperes
body: Done
created_at: 2025-03-26T22:46:01Z
author_association: CONTRIBUTOR
diff_hunk: @@ -5,32 +5,322 @@ This wiki page explains how to install Oppia Android on your local machine. If y
 ## Table of Contents
 
 - [Prepare developer environment](#prepare-developer-environment)
+- [Install Bazel](#install-bazel)
+  - [Bazel Set up for Mac](#bazel-set-up-for-mac)
+  - [Bazel Set up for Linux](#bazel-set-up-for-linux)
+  - [Bazel Set up for Windows](#bazel-set-up-for-windows)
 - [Install oppia-android](#install-oppia-android)
-- [Run the app from Android Studio](#run-the-app-from-android-studio)
+- [Opening the Project in Android Studio](#opening-the-project-in-android-studio)
 - [Set up and Run tests](#set-up-and-run-tests)
-  - [Step-by-Step guidance for setting up and running app modules robolectric test](#step-by-step-guidance-for-setting-up-and-running-app-modules-robolectric-test)
-  - [For tests that are in non-app modules, such as **domain** or **utility**:](#for-tests-that-are-in-non-app-modules-such-as-domain-or-utility)
-
+  - [Running app module tests](#running-app-module-tests)
+  - [Running non-app module tests](#running-non-app-module-tests)
+- [Next Steps](#next-steps)
+- [Troubleshooting Installation](#troubleshooting-installation)
 
 ## Prepare developer environment
 
-1. Download/Install [Android Studio Bumblebee | Patch 3](https://developer.android.com/studio/archive).
+1. Download and install Android Studio **Giraffe** from [this location](https://developer.android.com/studio/archive).
+   **Note**: You may try newer or older versions of Android Studio, but we can't guarantee good support.
 
-   **Note**: We recommend installing **Android Studio Bumblebee | 2021.1.1 Patch 3** because newer versions of Android Studio[ do not support running tests where shared source sets are used](https://issuetracker.google.com/issues/232007221#comment18), a configuration we use at Oppia.
+2. Configure your Android Studio
+   - From your PC's application menu, open Android Studio. 
+   - On the welcome screen, find the "more options menu" and select **SDK Manager**
+     
+     <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/efcc4e6e-b6ba-44fc-9c96-aa381de83911" />
+    
+   - In the "SDK Platforms" tab (which is the default), select `API Level 30` and also `API Level 34`.
+   - Also, navigate to the "SDK Tools" tab, click the "Show Package Details" checkbox at the bottom right, then click on "Android SDK Build-Tools 34-rc1" and select 32.0.0 (this is needed for Bazel support).
 
-   **Direct download Url**: [Windows](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-windows.exe) | [Linux](https://redirector.gvt1.com/edgedl/android/studio/ide-zips/2021.1.1.23/android-studio-2021.1.1.23-linux.tar.gz) | [Intel Mac](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-mac.dmg) | [Apple Silicon Mac](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-mac_arm.dmg)
+   - Then, click "Apply" to download and install these two SDKs/Tools.
+     - On this screen, note the **Android SDK Location**, which is set as the ANDROID_HOME variable in the Bazel setup step below.
 
-   You can have multiple versions of Android Studio installed on your machine at the same time.
+3. Prepare a test device
+   You require a physical Android device or an Android emulator to run the Oppia app. 
+   - Physical devices are useful for a real-user experience feel, and testing with [accessibility tools](https://github.com/oppia/oppia-android/wiki/Accessibility-A11y-Guide#setting-up-accessibility-scanner-and-talkback).
+   
+     **Set up a physical device for development**
+      - On the device, open the **Settings** app, select **Developer options**, and then **enable USB debugging** (if applicable).
+        - If you don't see **Developer options**, you might need to enable developer mode first. Follow [these instructions](https://developer.android.com/studio/debug/dev-options#enable) to do so.
+        - Connect to your device using USB.
+        - Verify that your device is connected by running the `adb devices` command from your terminal.
+   
+      - Emulators provide the flexibility of testing the application on a variety of devices and Android API levels without needing to have each physical device.
+   
+     **Set up an Emulator**
+      - For the best experience, you should use the emulator in Android Studio on a computer with at least the following specs:
+        - 16 GB RAM
+        - 64-bit Windows 10 or higher, MacOS 12 or higher, Linux, or ChromeOS operating system
+        - 16 GB disk space
+     
+      - If you don't have these specs, the emulator might still run but not smoothly. In this case, consider testing on a physical device.
 
-2. Configure your Android Studio
-   - In Android Studio, open Tools > SDK Manager.
-     - In the "SDK Platforms" tab (which is the default), select `API Level 28` and also `API Level 30` (for Bazel support).
-     - Also, navigate to the "SDK Tools" tab, click the "Show Package Details" checkbox at the bottom right, then click on "Android SDK Build-Tools 34-rc1" and select 32.0.0 (this is needed for Bazel support).
+      - On the welcome screen, find the "more options menu" and select **Virtual Device Manager**
+     
+        <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/efcc4e6e-b6ba-44fc-9c96-aa381de83911" />
+         
+        * If you already have a project open in Android Studio, in the right hand toolbar, locate `device Manager`.
path: wiki/Installing-Oppia-Android.md
user: login: adhiamboperes
body: Done
created_at: 2025-03-26T22:47:00Z
author_association: CONTRIBUTOR
diff_hunk: @@ -5,32 +5,322 @@ This wiki page explains how to install Oppia Android on your local machine. If y
 ## Table of Contents
 
 - [Prepare developer environment](#prepare-developer-environment)
+- [Install Bazel](#install-bazel)
+  - [Bazel Set up for Mac](#bazel-set-up-for-mac)
+  - [Bazel Set up for Linux](#bazel-set-up-for-linux)
+  - [Bazel Set up for Windows](#bazel-set-up-for-windows)
 - [Install oppia-android](#install-oppia-android)
-- [Run the app from Android Studio](#run-the-app-from-android-studio)
+- [Opening the Project in Android Studio](#opening-the-project-in-android-studio)
 - [Set up and Run tests](#set-up-and-run-tests)
-  - [Step-by-Step guidance for setting up and running app modules robolectric test](#step-by-step-guidance-for-setting-up-and-running-app-modules-robolectric-test)
-  - [For tests that are in non-app modules, such as **domain** or **utility**:](#for-tests-that-are-in-non-app-modules-such-as-domain-or-utility)
-
+  - [Running app module tests](#running-app-module-tests)
+  - [Running non-app module tests](#running-non-app-module-tests)
+- [Next Steps](#next-steps)
+- [Troubleshooting Installation](#troubleshooting-installation)
 
 ## Prepare developer environment
 
-1. Download/Install [Android Studio Bumblebee | Patch 3](https://developer.android.com/studio/archive).
+1. Download and install Android Studio **Giraffe** from [this location](https://developer.android.com/studio/archive).
+   **Note**: You may try newer or older versions of Android Studio, but we can't guarantee good support.
 
-   **Note**: We recommend installing **Android Studio Bumblebee | 2021.1.1 Patch 3** because newer versions of Android Studio[ do not support running tests where shared source sets are used](https://issuetracker.google.com/issues/232007221#comment18), a configuration we use at Oppia.
+2. Configure your Android Studio
+   - From your PC's application menu, open Android Studio. 
+   - On the welcome screen, find the "more options menu" and select **SDK Manager**
+     
+     <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/efcc4e6e-b6ba-44fc-9c96-aa381de83911" />
+    
+   - In the "SDK Platforms" tab (which is the default), select `API Level 30` and also `API Level 34`.
+   - Also, navigate to the "SDK Tools" tab, click the "Show Package Details" checkbox at the bottom right, then click on "Android SDK Build-Tools 34-rc1" and select 32.0.0 (this is needed for Bazel support).
 
-   **Direct download Url**: [Windows](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-windows.exe) | [Linux](https://redirector.gvt1.com/edgedl/android/studio/ide-zips/2021.1.1.23/android-studio-2021.1.1.23-linux.tar.gz) | [Intel Mac](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-mac.dmg) | [Apple Silicon Mac](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-mac_arm.dmg)
+   - Then, click "Apply" to download and install these two SDKs/Tools.
+     - On this screen, note the **Android SDK Location**, which is set as the ANDROID_HOME variable in the Bazel setup step below.
 
-   You can have multiple versions of Android Studio installed on your machine at the same time.
+3. Prepare a test device
+   You require a physical Android device or an Android emulator to run the Oppia app. 
+   - Physical devices are useful for a real-user experience feel, and testing with [accessibility tools](https://github.com/oppia/oppia-android/wiki/Accessibility-A11y-Guide#setting-up-accessibility-scanner-and-talkback).
+   
+     **Set up a physical device for development**
+      - On the device, open the **Settings** app, select **Developer options**, and then **enable USB debugging** (if applicable).
+        - If you don't see **Developer options**, you might need to enable developer mode first. Follow [these instructions](https://developer.android.com/studio/debug/dev-options#enable) to do so.
+        - Connect to your device using USB.
+        - Verify that your device is connected by running the `adb devices` command from your terminal.
+   
+      - Emulators provide the flexibility of testing the application on a variety of devices and Android API levels without needing to have each physical device.
+   
+     **Set up an Emulator**
+      - For the best experience, you should use the emulator in Android Studio on a computer with at least the following specs:
+        - 16 GB RAM
+        - 64-bit Windows 10 or higher, MacOS 12 or higher, Linux, or ChromeOS operating system
+        - 16 GB disk space
+     
+      - If you don't have these specs, the emulator might still run but not smoothly. In this case, consider testing on a physical device.
 
-2. Configure your Android Studio
-   - In Android Studio, open Tools > SDK Manager.
-     - In the "SDK Platforms" tab (which is the default), select `API Level 28` and also `API Level 30` (for Bazel support).
-     - Also, navigate to the "SDK Tools" tab, click the "Show Package Details" checkbox at the bottom right, then click on "Android SDK Build-Tools 34-rc1" and select 32.0.0 (this is needed for Bazel support).
+      - On the welcome screen, find the "more options menu" and select **Virtual Device Manager**
+     
+        <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/efcc4e6e-b6ba-44fc-9c96-aa381de83911" />
+         
+        * If you already have a project open in Android Studio, in the right hand toolbar, locate `device Manager`.
+      - Click the **+**, and then click **Create Virtual Device**.
+      - Follow the wizard to create a phone and a tablet AVD, setting the **system image** to be one of `API Level 30` or `API Level 34` as installed above.
+      - After creating your devices, you will be able to see a list of all the devices on the device manager panel.
+      - For more information on the different configurations available for AVDs, please visit the [official documentation page.](https://developer.android.com/studio/run/managing-avds)
 
-   - Then, click "Apply" to download and install these two SDKs/Tools.
+## Install Bazel
+### Instructions
+
+**The steps to setting up Bazel are:**
+1. Install Bazel
+2. Set Bazel and ANDROID_HOME paths permanently in your terminal
+3. Verify that the build is working
+
+The expected output of `bazel --version` once Bazel set up is successful is:
+
+```
+bazel 6.5.0
+```
+
+### Bazel Set up for Mac
+It is recommended to use the binary installer steps outline below. For other ways to install Bazel on Mac, refer to the [official page](https://bazel.build/install/os-x).
path: wiki/Installing-Oppia-Android.md
user: login: adhiamboperes
body: Done
created_at: 2025-03-26T22:47:20Z
author_association: CONTRIBUTOR
diff_hunk: @@ -5,32 +5,322 @@ This wiki page explains how to install Oppia Android on your local machine. If y
 ## Table of Contents
 
 - [Prepare developer environment](#prepare-developer-environment)
+- [Install Bazel](#install-bazel)
+  - [Bazel Set up for Mac](#bazel-set-up-for-mac)
+  - [Bazel Set up for Linux](#bazel-set-up-for-linux)
+  - [Bazel Set up for Windows](#bazel-set-up-for-windows)
 - [Install oppia-android](#install-oppia-android)
-- [Run the app from Android Studio](#run-the-app-from-android-studio)
+- [Opening the Project in Android Studio](#opening-the-project-in-android-studio)
 - [Set up and Run tests](#set-up-and-run-tests)
-  - [Step-by-Step guidance for setting up and running app modules robolectric test](#step-by-step-guidance-for-setting-up-and-running-app-modules-robolectric-test)
-  - [For tests that are in non-app modules, such as **domain** or **utility**:](#for-tests-that-are-in-non-app-modules-such-as-domain-or-utility)
-
+  - [Running app module tests](#running-app-module-tests)
+  - [Running non-app module tests](#running-non-app-module-tests)
+- [Next Steps](#next-steps)
+- [Troubleshooting Installation](#troubleshooting-installation)
 
 ## Prepare developer environment
 
-1. Download/Install [Android Studio Bumblebee | Patch 3](https://developer.android.com/studio/archive).
+1. Download and install Android Studio **Giraffe** from [this location](https://developer.android.com/studio/archive).
+   **Note**: You may try newer or older versions of Android Studio, but we can't guarantee good support.
 
-   **Note**: We recommend installing **Android Studio Bumblebee | 2021.1.1 Patch 3** because newer versions of Android Studio[ do not support running tests where shared source sets are used](https://issuetracker.google.com/issues/232007221#comment18), a configuration we use at Oppia.
+2. Configure your Android Studio
+   - From your PC's application menu, open Android Studio. 
+   - On the welcome screen, find the "more options menu" and select **SDK Manager**
+     
+     <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/efcc4e6e-b6ba-44fc-9c96-aa381de83911" />
+    
+   - In the "SDK Platforms" tab (which is the default), select `API Level 30` and also `API Level 34`.
+   - Also, navigate to the "SDK Tools" tab, click the "Show Package Details" checkbox at the bottom right, then click on "Android SDK Build-Tools 34-rc1" and select 32.0.0 (this is needed for Bazel support).
 
-   **Direct download Url**: [Windows](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-windows.exe) | [Linux](https://redirector.gvt1.com/edgedl/android/studio/ide-zips/2021.1.1.23/android-studio-2021.1.1.23-linux.tar.gz) | [Intel Mac](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-mac.dmg) | [Apple Silicon Mac](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-mac_arm.dmg)
+   - Then, click "Apply" to download and install these two SDKs/Tools.
+     - On this screen, note the **Android SDK Location**, which is set as the ANDROID_HOME variable in the Bazel setup step below.
 
-   You can have multiple versions of Android Studio installed on your machine at the same time.
+3. Prepare a test device
+   You require a physical Android device or an Android emulator to run the Oppia app. 
+   - Physical devices are useful for a real-user experience feel, and testing with [accessibility tools](https://github.com/oppia/oppia-android/wiki/Accessibility-A11y-Guide#setting-up-accessibility-scanner-and-talkback).
+   
+     **Set up a physical device for development**
+      - On the device, open the **Settings** app, select **Developer options**, and then **enable USB debugging** (if applicable).
+        - If you don't see **Developer options**, you might need to enable developer mode first. Follow [these instructions](https://developer.android.com/studio/debug/dev-options#enable) to do so.
+        - Connect to your device using USB.
+        - Verify that your device is connected by running the `adb devices` command from your terminal.
+   
+      - Emulators provide the flexibility of testing the application on a variety of devices and Android API levels without needing to have each physical device.
+   
+     **Set up an Emulator**
+      - For the best experience, you should use the emulator in Android Studio on a computer with at least the following specs:
+        - 16 GB RAM
+        - 64-bit Windows 10 or higher, MacOS 12 or higher, Linux, or ChromeOS operating system
+        - 16 GB disk space
+     
+      - If you don't have these specs, the emulator might still run but not smoothly. In this case, consider testing on a physical device.
 
-2. Configure your Android Studio
-   - In Android Studio, open Tools > SDK Manager.
-     - In the "SDK Platforms" tab (which is the default), select `API Level 28` and also `API Level 30` (for Bazel support).
-     - Also, navigate to the "SDK Tools" tab, click the "Show Package Details" checkbox at the bottom right, then click on "Android SDK Build-Tools 34-rc1" and select 32.0.0 (this is needed for Bazel support).
+      - On the welcome screen, find the "more options menu" and select **Virtual Device Manager**
+     
+        <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/efcc4e6e-b6ba-44fc-9c96-aa381de83911" />
+         
+        * If you already have a project open in Android Studio, in the right hand toolbar, locate `device Manager`.
+      - Click the **+**, and then click **Create Virtual Device**.
+      - Follow the wizard to create a phone and a tablet AVD, setting the **system image** to be one of `API Level 30` or `API Level 34` as installed above.
+      - After creating your devices, you will be able to see a list of all the devices on the device manager panel.
+      - For more information on the different configurations available for AVDs, please visit the [official documentation page.](https://developer.android.com/studio/run/managing-avds)
 
-   - Then, click "Apply" to download and install these two SDKs/Tools.
+## Install Bazel
+### Instructions
+
+**The steps to setting up Bazel are:**
+1. Install Bazel
+2. Set Bazel and ANDROID_HOME paths permanently in your terminal
+3. Verify that the build is working
+
+The expected output of `bazel --version` once Bazel set up is successful is:
+
+```
+bazel 6.5.0
+```
+
+### Bazel Set up for Mac
+It is recommended to use the binary installer steps outline below. For other ways to install Bazel on Mac, refer to the [official page](https://bazel.build/install/os-x).
+
+**Step 1: Install Xcode command line tools**
+
+In macOS 14 or earlier, it is sufficient to install the Xcode command line tools package by using xcode-select:
+
+```
+xcode-select --install
+```
+
+Otherwise, for macOS 15 and later, you must have Xcode 6.1 or later installed on your system.
+
+Download Xcode from the [App Store](https://apps.apple.com/us/app/xcode/id497799835) or the [Apple Developer site](https://developer.apple.com/download/more/?=xcode).
+
+Once Xcode is installed, accept the license agreement for all users with the following command:
+
+```
+sudo xcodebuild -license accept
+```
+
+**Step 2: Download the Bazel installer**
+
+Click [here](https://github.com/bazelbuild/bazel/releases/download/6.5.0/bazel-6.5.0-installer-darwin-x86_64.sh) to download the Bazel 6.5.0 binary installer.
+
+**Step 3: Run the installer**
+
+Run the Bazel installer as follows:
+
+```shell
+chmod +x "bazel-6.5.0-installer-darwin-x86_64.sh"
+./bazel-6.5.0-installer-darwin-x86_64.sh --user
+```
+
+**Step 4: Set up your environment**
+
+You must set the path for `Bazel` and `ANDROID_HOME` before running bazel build for oppia-android, otherwise you will get an error.
+
+If you ran the Bazel installer with the `--user` flag as above, the Bazel executable is installed in your $HOME/bin directory. It’s a good idea to add this directory to your default paths, as follows:
+
+```shell
+export PATH="$PATH:$HOME/bin"
+```
+
+To set the `ANDROID_HOME` path permanently in your terminal run these commands:
+
+```
+sudo nano /etc/paths
+```
+- Enter your password, when prompted.
+- Go to the bottom of the file, and enter this path: `$HOME/Library/Android/sdk`
+- Hit control-x to quit.
+- Enter “Y” to save the modified buffer.
+- That’s it! To test it, in a new terminal window, type: `echo $PATH`
+
+**Step 5: Verify that the build is working**
+
+Run the following command in your terminal:
+
+```
+bazel --version
+```
+
+### Bazel Set up for Linux
+This section covers Bazel installation on Ubuntu. 
+
+Recommendations:
+- use Ubuntu 18.04 (LTS), 20.04 (LTS), or 22.04 (LTS).
+- use ``apt`` installation instructions.
+
+- **Note**: if you encounter any errors related to `cURL`, please set up cURL on your machine using `sudo apt install curl`.
+
+**Step 1: Add Bazel distribution URI as a package source**
+
+This is a one-time setup step.
+
+```
+sudo apt install apt-transport-https curl gnupg -y
+curl -fsSL https://bazel.build/bazel-release.pub.gpg | gpg --dearmor >bazel-archive-keyring.gpg
+sudo mv bazel-archive-keyring.gpg /usr/share/keyrings
+echo "deb [arch=amd64 signed-by=/usr/share/keyrings/bazel-archive-keyring.gpg] https://storage.googleapis.com/bazel-apt stable jdk1.8" | sudo tee /etc/apt/sources.list.d/bazel.list
+```
+
+**Step 2: Install and update Bazel**
+
+Run:
+```shell
+sudo apt-get update && sudo apt-get install bazel-6.5.0
+```
+
+**Step 3: Set up your environment**
+
+Ensure that your `ANDROID_HOME` environment variable is set to the location of your Android SDK. Assuming the SDK is installed to default locations, you can use the following commands to set the `ANDROID_HOME` variable:
+
+```
+export ANDROID_HOME=$HOME/Android/Sdk/
+```
+
+**Step 4: Verify that the build is working**
+
+Run the following command in your terminal:
+
+```
+bazel --version
+```
+
+### Bazel Set up for Windows
+This page outlines one way to allow Bazel to be used in CLI form on Windows. Please note that **this support is currently experimental**. We suggest that you post a discussion at [github-discussions](https://github.com/oppia/oppia-android/discussions/categories/q-a-installation) if you run into any problems.
+
+Unlike Unix-based systems where Bazel runs natively without issue, the current solution on Windows is to install an Ubuntu-based subsystem. Windows currently only supports a terminal experience in this subsystem (though there is a prerelease version of the software with GUI support) which means Android Studio will not be supported. You will need to continue using the Windows version of Android Studio and only use the Linux subsystem for building & running Robolectric or JUnit-based tests.
+
+Due to the issues mentioned above, we recommend dual-booting your PC with Linux. However, if you choose to use Windows, please follow the instructions below:
+
+**Main prerequisites**:
+- Windows 10+: These instructions are geared towards users of Windows 10+ (older versions will not be compatible). If you're in using an older version of Windows, please follow up with a comment on [this issue](https://github.com/oppia/oppia-android/issues/3371).
path: wiki/Installing-Oppia-Android.md
user: login: adhiamboperes
body: Done
created_at: 2025-03-26T22:48:08Z
author_association: CONTRIBUTOR
diff_hunk: @@ -150,8 +451,105 @@ We strongly recommend running tests on Robolectric which is faster because it do
 
 - To learn about how we write tests at oppia-android, please refer to: [Oppia Android Testing](https://github.com/oppia/oppia-android/wiki/Oppia-Android-Testing).
 
-- To get started with Bazel, please see [Oppia-Bazel-Setup-Instructions](https://github.com/oppia/oppia-android/wiki/Oppia-Bazel-Setup-Instructions) and follow the instructions appropriate to your OS.
-
-- If you run into any issues during your setup, search our [discussions](https://github.com/oppia/oppia-android/discussions) forum or start a new discussion.
-
-- Please see  [Troubleshooting-Installation](https://github.com/oppia/oppia-android/wiki/Troubleshooting-Installation) for solutions to some common setup issues.
+- An important reference to go back to as you continue developing with Bazel is the [Bazel User Guide](https://github.com/oppia/oppia-android/wiki/Bazel-User-Guide).
+
+### Troubleshooting Installation
+#### General issues
+1. If the Static Checks on your PR keeps failing, please refer to [instructions on running static checks locally](https://github.com/oppia/oppia-android/wiki/Static-Analysis-Checks#how-to-run-static-checks-locally) in order to catch these errors before pushing.
path: wiki/Installing-Oppia-Android.md
user: login: adhiamboperes
body: Done.
created_at: 2025-03-26T22:48:49Z
author_association: CONTRIBUTOR
diff_hunk: @@ -264,7 +264,7 @@ To fix failing tests from GitHub CI individually, follow the steps below.
 - Alternatively, in Android Studio, go to the `.github` folder and find the [static_checks.yml](https://github.com/oppia/oppia-android/blob/develop/.github/workflows/static_checks.yml) file. Search for the line that corresponds to the name of the job that failed. You can then run the same script on your local terminal.
 - You can also go to scripts/static_checks.sh to view the failing check and run it locally.
 
-Note: Before running the script command in your local terminal, make sure you have Bazel installed. To learn how to set up Bazel for Oppia Android, follow these [instructions](https://github.com/oppia/oppia-android/wiki/Oppia-Bazel-Setup-Instructions). Also make sure you have oppia-android-tools installed since static checks rely on these tools to be able to perform some of the checks. To install oppia-android-tools, run `bash scripts/setup.sh` in the oppia-android directory.
+Note: Before running the script command in your local terminal, make sure you have Bazel installed. To learn how to set up Bazel for Oppia Android, follow these [instructions](https://github.com/oppia/oppia-android/wiki/Installing-Oppia-Android#install-bazel). Also make sure you have oppia-android-tools installed since static checks rely on these tools to be able to perform some of the checks. To install oppia-android-tools, run `bash scripts/setup.sh` in the oppia-android directory.
path: wiki/Static-Analysis-Checks.md
user: login: adhiamboperes
body: Done
created_at: 2025-03-26T22:51:26Z
author_association: CONTRIBUTOR
diff_hunk: @@ -0,0 +1,284 @@
+## Table of Contents
+
+- [Overview](#overview)
+- [Installation](#installation)
+  - [Building the app](#building-the-app)
+- [Running Tests](#running-tests)
+  - [How to Obtain a Test Target](#how-to-obtain-a-test-target)
+  - [Common Flags](#common-flags)
+  - [Running multiple test targets](#running-multiple-test-targets)
+- [Concepts and Terminology](#concepts-and-terminology)
+- [Syncing the Project](#syncing-the-project)
+
+## Overview
+Bazel is an open-source build and test tool similar to Make, Maven, and Gradle. It uses a human-readable, high-level build language.
+
+## Installation
+
+Follow the instructions on the [installation page](https://github.com/oppia/oppia-android/wiki/Installing-Oppia-Android#install-bazel) to set up Bazel.
+
+### Building the app
+
+The [installation page](https://github.com/oppia/oppia-android/wiki/Installing-Oppia-Android#install-bazel) provides information on running the project in Android Studio.
+
+You can also run the app from the command line using the commands detailed below.
+
+Using the command line is helpful in instances when you need to build and run some targets outside of Android Studio.
+
+Run the following commands in your terminal. All Bazel commands must be run from the root of the `oppia-android` directory otherwise they will fail.
+
+Note that on the first run, these commands may take 10-20 minutes to complete depending on the performance of your machine. Subsequent runs will be much faster.
+
+**On SDK 29 and below, run**:
+   ```
+   bazel mobile-install //:oppia_dev_binary
+   ```
+This will build, install and launch the app on your device.
+
+**On SDK 30 and newer, run**:
+   ```
+   bazel build //:oppia_dev
+   ```
+followed by:
+   ```
+   adb install bazel-bin/oppia_dev_binary.apk  
+   ```
+* Starting from SDK 30, incremental builds, like those executed using `bazel mobile-install`, are no longer permitted, necessitating the use of two separate commands.
+
+If everything is working, you should see output like the following:
+
+```
+Target //:oppia_dev_binary up-to-date:
+  bazel-bin/oppia_dev_binary_deploy.jar
+  bazel-bin/oppia_dev_binary_unsigned.apk
+  bazel-bin/oppia_dev_binary.apk
+INFO: Elapsed time: 37.155s, Critical Path: 17.24s
+INFO: 99 processes: 2 internal, 23 darwin-sandbox, 74 worker.
+INFO: Build completed successfully, 99 total actions
+Performing Streamed Install
+Success
+```
+
+Note also that the ``oppia_dev.aab`` under the ``bazel-bin`` directory of your local copy of Oppia Android should be a fully functioning development version of the app that can be installed using bundle-tool. However, it's recommended to deploy Oppia to an emulator or connected device using the `mobile-install` command.
+
+## Running Tests
+
+The bazel test command is used to build and run tests in a Bazel workspace. It ensures that the specified test targets are built and executed in a sandboxed environment for reproducibility.
+
+**Syntax**
+
+```shell
+bazel test //path/to:target
+```
+
+### How to Obtain a Test Target
+A test target in Bazel refers to a specific testable entity defined in a BUILD file. It represents a test rule, such as `java_test` or `android_test`, that Bazel can build and execute.
+
+To ensure you always use the correct test target, follow one of these steps:
+1. If the test file is open in Android Studio:
+   * Right-click to open the context menu and select **Copy BUILD target string** as shown.
+     
+     ![Screenshot 2025-03-18 at 22 30 22](https://github.com/user-attachments/assets/286ebcb6-4f4e-4055-b6f0-4c070b039375)
+   
+   * Paste the target to the bazel test command, e.g. `bazel test //domain/src/test/java/org/oppia/android/domain/onboarding:AppStartupStateControllerTest`
+
+2. If the test file is open in Android Studio, but **Copy BUILD target string** is not available in the context menu:
+Sometimes the **Copy BUILD target string** is not available in the context menu either due to sync issues or modularization issues. You can still copy the file path, and pass it to the test command.
+   * In the AS sidebar, right click on the file, and select `copy path/reference`.
+     or
+   * Right-click on the file tab and then click `copy path/reference`.
+   * Next, select `copy path from repository root`. 
+   * Paste the copied path to the bazel test command in the terminal and remove the `.kt` extension, e.g. `bazel test domain/src/test/java/org/oppia/android/domain/onboarding/AppStartupStateControllerTest`.
+
+With this syntax, Bazel implicitly converts the file path into a target if it matches a test rule in the BUILD file. If the file is not part of a test target in the BUILD file, this command may fail.
+**When to use this**: If you are unsure about the exact Bazel target and want a quick way to run a test.
+
+3. Querying for a target
+Using the explicit Bazel target (// syntax) is more reliable compared to the file path syntax above. However, in cases such as running the test outside android studio, you may not know the target. In this case, you can use Bazel's `query` command to retrieve the correct test target:
+   * Copy the relative path of the test file.
+   * Run the following command in your terminal to get the test’s Bazel target: `bazel query relative-path-of-test-file`
+   Example
+   
+   ```shell
+   bazel query domain/src/test/java/org/oppia/android/domain/onboarding/AppStartupStateControllerTest.kt
+   ```
+   * The output will be a Bazel target that starts with //. Copy the target and remove the .kt extension.
+   * Use this target in the bazel test command, e.g. `bazel test //domain/src/test/java/org/oppia/android/domain/onboarding:AppStartupStateControllerTest`.
+
+### Common Flags
+
+`--test_output=all` → Show full test output.
+`--cache_test_results=no` → Force re-running tests even if cached.
+`--test_filter=ClassName#methodName` → Run specific test cases.
+`--runs_per_test=100` → Specifies number of times to run each test.
+
+### Running multiple test targets
+To run all the test targets in the app module:
+
+```
+bazel test //app/...
+```
+
+To run all the test targets in the project (note that this would be extremely slow and is not recommended):
+
+```
+bazel test //...
+```
+
+To run multiple test targets at once:
+
+```
+bazel test -- //path/to/target/FirstTest //path/to/target/SecondTest
+```
+
+## Concepts and Terminology
+**[Workspace](https://github.com/oppia/oppia-android/blob/7344270032ac242b1b8987f1b51c8b5aa4f14ce3/WORKSPACE#L2)**
+
+A workspace is a directory where we specify the targeted SDK version, required dependencies, and corresponding Rules. The directory containing the WORKSPACE file is the root of the main repository, which in our case, is the `oppia-android` root directory.
+**[Packages](https://github.com/oppia/oppia-android/tree/develop/app)**
+
+A package is defined as a directory containing a file named BUILD or BUILD.bazel.
+
+**[Binary rules](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/BUILD.bazel#L3)**
+
+A rule specifies the relationship between inputs and outputs, and the steps to build the outputs.
+In Android, rules are defined using `android_binary`. Android rules for testing are `android_instrumentation_test` and `android_local_test`.
+
+**[BUILD files](https://github.com/oppia/oppia-android/blob/7344270032ac242b1b8987f1b51c8b5aa4f14ce3/app/BUILD.bazel#L3)**
+
+Every package contains a BUILD file. This file is written in Starlark Language. In this Build file for module-level, we generally define `android_library`, `kt_android_library` to build our package files as per the requirement.
+
+**[Dependencies](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/BUILD.bazel#L16)**
+
+A target A depends upon a target B if B is needed by A at build. `A -> B`
+
+```
+deps = [ "//app",]
+```
+Here, `deps` is used to define the dependencies which is a type of dependencies called `deps dependencies` and it includes the files/directory/target which are dependent. From the above example the dependency is the `app` target which is defined in the [Build file of app package](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/app/BUILD.bazel#L616).
+
+Example of Dependencies
+1. [srcs dependencies](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/app/BUILD.bazel#L617)
+2. [deps dependencies](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/app/BUILD.bazel#L622)
+
+**[Loading an extension](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/app/BUILD.bazel#L13)**
+
+Bazel extensions are files ending in .bzl. Use the load statement to import a symbol from an extension.
+
+```
+load("@io_bazel_rules_kotlin//kotlin:android.bzl", "kt_android_library")
+```
+Here, we are loading `android.bzl` and we are going to use it with a symbol name `kt_android_library`.
+Arguments to the load function must be string literals. load statements must appear at top-level in the file.
path: wiki/Bazel-User-Guide.md
user: login: adhiamboperes
body: Done
created_at: 2025-03-26T22:52:28Z
author_association: CONTRIBUTOR
diff_hunk: @@ -0,0 +1,284 @@
+## Table of Contents
+
+- [Overview](#overview)
+- [Installation](#installation)
+  - [Building the app](#building-the-app)
+- [Running Tests](#running-tests)
+  - [How to Obtain a Test Target](#how-to-obtain-a-test-target)
+  - [Common Flags](#common-flags)
+  - [Running multiple test targets](#running-multiple-test-targets)
+- [Concepts and Terminology](#concepts-and-terminology)
+- [Syncing the Project](#syncing-the-project)
+
+## Overview
+Bazel is an open-source build and test tool similar to Make, Maven, and Gradle. It uses a human-readable, high-level build language.
+
+## Installation
+
+Follow the instructions on the [installation page](https://github.com/oppia/oppia-android/wiki/Installing-Oppia-Android#install-bazel) to set up Bazel.
+
+### Building the app
+
+The [installation page](https://github.com/oppia/oppia-android/wiki/Installing-Oppia-Android#install-bazel) provides information on running the project in Android Studio.
+
+You can also run the app from the command line using the commands detailed below.
+
+Using the command line is helpful in instances when you need to build and run some targets outside of Android Studio.
+
+Run the following commands in your terminal. All Bazel commands must be run from the root of the `oppia-android` directory otherwise they will fail.
+
+Note that on the first run, these commands may take 10-20 minutes to complete depending on the performance of your machine. Subsequent runs will be much faster.
+
+**On SDK 29 and below, run**:
+   ```
+   bazel mobile-install //:oppia_dev_binary
+   ```
+This will build, install and launch the app on your device.
+
+**On SDK 30 and newer, run**:
+   ```
+   bazel build //:oppia_dev
+   ```
+followed by:
+   ```
+   adb install bazel-bin/oppia_dev_binary.apk  
+   ```
+* Starting from SDK 30, incremental builds, like those executed using `bazel mobile-install`, are no longer permitted, necessitating the use of two separate commands.
+
+If everything is working, you should see output like the following:
+
+```
+Target //:oppia_dev_binary up-to-date:
+  bazel-bin/oppia_dev_binary_deploy.jar
+  bazel-bin/oppia_dev_binary_unsigned.apk
+  bazel-bin/oppia_dev_binary.apk
+INFO: Elapsed time: 37.155s, Critical Path: 17.24s
+INFO: 99 processes: 2 internal, 23 darwin-sandbox, 74 worker.
+INFO: Build completed successfully, 99 total actions
+Performing Streamed Install
+Success
+```
+
+Note also that the ``oppia_dev.aab`` under the ``bazel-bin`` directory of your local copy of Oppia Android should be a fully functioning development version of the app that can be installed using bundle-tool. However, it's recommended to deploy Oppia to an emulator or connected device using the `mobile-install` command.
+
+## Running Tests
+
+The bazel test command is used to build and run tests in a Bazel workspace. It ensures that the specified test targets are built and executed in a sandboxed environment for reproducibility.
+
+**Syntax**
+
+```shell
+bazel test //path/to:target
+```
+
+### How to Obtain a Test Target
+A test target in Bazel refers to a specific testable entity defined in a BUILD file. It represents a test rule, such as `java_test` or `android_test`, that Bazel can build and execute.
+
+To ensure you always use the correct test target, follow one of these steps:
+1. If the test file is open in Android Studio:
+   * Right-click to open the context menu and select **Copy BUILD target string** as shown.
+     
+     ![Screenshot 2025-03-18 at 22 30 22](https://github.com/user-attachments/assets/286ebcb6-4f4e-4055-b6f0-4c070b039375)
+   
+   * Paste the target to the bazel test command, e.g. `bazel test //domain/src/test/java/org/oppia/android/domain/onboarding:AppStartupStateControllerTest`
+
+2. If the test file is open in Android Studio, but **Copy BUILD target string** is not available in the context menu:
+Sometimes the **Copy BUILD target string** is not available in the context menu either due to sync issues or modularization issues. You can still copy the file path, and pass it to the test command.
+   * In the AS sidebar, right click on the file, and select `copy path/reference`.
+     or
+   * Right-click on the file tab and then click `copy path/reference`.
+   * Next, select `copy path from repository root`. 
+   * Paste the copied path to the bazel test command in the terminal and remove the `.kt` extension, e.g. `bazel test domain/src/test/java/org/oppia/android/domain/onboarding/AppStartupStateControllerTest`.
+
+With this syntax, Bazel implicitly converts the file path into a target if it matches a test rule in the BUILD file. If the file is not part of a test target in the BUILD file, this command may fail.
+**When to use this**: If you are unsure about the exact Bazel target and want a quick way to run a test.
+
+3. Querying for a target
+Using the explicit Bazel target (// syntax) is more reliable compared to the file path syntax above. However, in cases such as running the test outside android studio, you may not know the target. In this case, you can use Bazel's `query` command to retrieve the correct test target:
+   * Copy the relative path of the test file.
+   * Run the following command in your terminal to get the test’s Bazel target: `bazel query relative-path-of-test-file`
+   Example
+   
+   ```shell
+   bazel query domain/src/test/java/org/oppia/android/domain/onboarding/AppStartupStateControllerTest.kt
+   ```
+   * The output will be a Bazel target that starts with //. Copy the target and remove the .kt extension.
+   * Use this target in the bazel test command, e.g. `bazel test //domain/src/test/java/org/oppia/android/domain/onboarding:AppStartupStateControllerTest`.
+
+### Common Flags
+
+`--test_output=all` → Show full test output.
+`--cache_test_results=no` → Force re-running tests even if cached.
+`--test_filter=ClassName#methodName` → Run specific test cases.
+`--runs_per_test=100` → Specifies number of times to run each test.
+
+### Running multiple test targets
+To run all the test targets in the app module:
+
+```
+bazel test //app/...
+```
+
+To run all the test targets in the project (note that this would be extremely slow and is not recommended):
+
+```
+bazel test //...
+```
+
+To run multiple test targets at once:
+
+```
+bazel test -- //path/to/target/FirstTest //path/to/target/SecondTest
+```
+
+## Concepts and Terminology
+**[Workspace](https://github.com/oppia/oppia-android/blob/7344270032ac242b1b8987f1b51c8b5aa4f14ce3/WORKSPACE#L2)**
+
+A workspace is a directory where we specify the targeted SDK version, required dependencies, and corresponding Rules. The directory containing the WORKSPACE file is the root of the main repository, which in our case, is the `oppia-android` root directory.
+**[Packages](https://github.com/oppia/oppia-android/tree/develop/app)**
+
+A package is defined as a directory containing a file named BUILD or BUILD.bazel.
+
+**[Binary rules](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/BUILD.bazel#L3)**
+
+A rule specifies the relationship between inputs and outputs, and the steps to build the outputs.
+In Android, rules are defined using `android_binary`. Android rules for testing are `android_instrumentation_test` and `android_local_test`.
+
+**[BUILD files](https://github.com/oppia/oppia-android/blob/7344270032ac242b1b8987f1b51c8b5aa4f14ce3/app/BUILD.bazel#L3)**
+
+Every package contains a BUILD file. This file is written in Starlark Language. In this Build file for module-level, we generally define `android_library`, `kt_android_library` to build our package files as per the requirement.
+
+**[Dependencies](https://github.com/oppia/oppia-android/blob/ba8d914480251e4a8543feb63a93b6c91e0a5a2f/BUILD.bazel#L16)**
+
+A target A depends upon a target B if B is needed by A at build. `A -> B`
path: wiki/Bazel-User-Guide.md
user: login: adhiamboperes
body: Done
created_at: 2025-03-26T22:53:09Z
author_association: CONTRIBUTOR
diff_hunk: @@ -0,0 +1,284 @@
+## Table of Contents
+
+- [Overview](#overview)
+- [Installation](#installation)
+  - [Building the app](#building-the-app)
+- [Running Tests](#running-tests)
+  - [How to Obtain a Test Target](#how-to-obtain-a-test-target)
+  - [Common Flags](#common-flags)
+  - [Running multiple test targets](#running-multiple-test-targets)
+- [Concepts and Terminology](#concepts-and-terminology)
+- [Syncing the Project](#syncing-the-project)
+
+## Overview
+Bazel is an open-source build and test tool similar to Make, Maven, and Gradle. It uses a human-readable, high-level build language.
+
+## Installation
+
+Follow the instructions on the [installation page](https://github.com/oppia/oppia-android/wiki/Installing-Oppia-Android#install-bazel) to set up Bazel.
+
+### Building the app
+
+The [installation page](https://github.com/oppia/oppia-android/wiki/Installing-Oppia-Android#install-bazel) provides information on running the project in Android Studio.
+
+You can also run the app from the command line using the commands detailed below.
+
+Using the command line is helpful in instances when you need to build and run some targets outside of Android Studio.
+
+Run the following commands in your terminal. All Bazel commands must be run from the root of the `oppia-android` directory otherwise they will fail.
+
+Note that on the first run, these commands may take 10-20 minutes to complete depending on the performance of your machine. Subsequent runs will be much faster.
+
+**On SDK 29 and below, run**:
+   ```
+   bazel mobile-install //:oppia_dev_binary
+   ```
+This will build, install and launch the app on your device.
+
+**On SDK 30 and newer, run**:
+   ```
+   bazel build //:oppia_dev
+   ```
+followed by:
+   ```
+   adb install bazel-bin/oppia_dev_binary.apk  
+   ```
+* Starting from SDK 30, incremental builds, like those executed using `bazel mobile-install`, are no longer permitted, necessitating the use of two separate commands.
+
+If everything is working, you should see output like the following:
+
+```
+Target //:oppia_dev_binary up-to-date:
+  bazel-bin/oppia_dev_binary_deploy.jar
+  bazel-bin/oppia_dev_binary_unsigned.apk
+  bazel-bin/oppia_dev_binary.apk
+INFO: Elapsed time: 37.155s, Critical Path: 17.24s
+INFO: 99 processes: 2 internal, 23 darwin-sandbox, 74 worker.
+INFO: Build completed successfully, 99 total actions
+Performing Streamed Install
+Success
+```
+
+Note also that the ``oppia_dev.aab`` under the ``bazel-bin`` directory of your local copy of Oppia Android should be a fully functioning development version of the app that can be installed using bundle-tool. However, it's recommended to deploy Oppia to an emulator or connected device using the `mobile-install` command.
+
+## Running Tests
+
+The bazel test command is used to build and run tests in a Bazel workspace. It ensures that the specified test targets are built and executed in a sandboxed environment for reproducibility.
+
+**Syntax**
+
+```shell
+bazel test //path/to:target
+```
+
+### How to Obtain a Test Target
+A test target in Bazel refers to a specific testable entity defined in a BUILD file. It represents a test rule, such as `java_test` or `android_test`, that Bazel can build and execute.
+
+To ensure you always use the correct test target, follow one of these steps:
+1. If the test file is open in Android Studio:
+   * Right-click to open the context menu and select **Copy BUILD target string** as shown.
+     
+     ![Screenshot 2025-03-18 at 22 30 22](https://github.com/user-attachments/assets/286ebcb6-4f4e-4055-b6f0-4c070b039375)
+   
+   * Paste the target to the bazel test command, e.g. `bazel test //domain/src/test/java/org/oppia/android/domain/onboarding:AppStartupStateControllerTest`
+
+2. If the test file is open in Android Studio, but **Copy BUILD target string** is not available in the context menu:
+Sometimes the **Copy BUILD target string** is not available in the context menu either due to sync issues or modularization issues. You can still copy the file path, and pass it to the test command.
path: wiki/Bazel-User-Guide.md
user: login: adhiamboperes
body: Done
created_at: 2025-03-26T22:54:09Z
author_association: CONTRIBUTOR
diff_hunk: @@ -5,32 +5,322 @@ This wiki page explains how to install Oppia Android on your local machine. If y
 ## Table of Contents
 
 - [Prepare developer environment](#prepare-developer-environment)
+- [Install Bazel](#install-bazel)
+  - [Bazel Set up for Mac](#bazel-set-up-for-mac)
+  - [Bazel Set up for Linux](#bazel-set-up-for-linux)
+  - [Bazel Set up for Windows](#bazel-set-up-for-windows)
 - [Install oppia-android](#install-oppia-android)
-- [Run the app from Android Studio](#run-the-app-from-android-studio)
+- [Opening the Project in Android Studio](#opening-the-project-in-android-studio)
 - [Set up and Run tests](#set-up-and-run-tests)
-  - [Step-by-Step guidance for setting up and running app modules robolectric test](#step-by-step-guidance-for-setting-up-and-running-app-modules-robolectric-test)
-  - [For tests that are in non-app modules, such as **domain** or **utility**:](#for-tests-that-are-in-non-app-modules-such-as-domain-or-utility)
-
+  - [Running app module tests](#running-app-module-tests)
+  - [Running non-app module tests](#running-non-app-module-tests)
+- [Next Steps](#next-steps)
+- [Troubleshooting Installation](#troubleshooting-installation)
 
 ## Prepare developer environment
 
-1. Download/Install [Android Studio Bumblebee | Patch 3](https://developer.android.com/studio/archive).
+1. Download and install Android Studio **Giraffe** from [this location](https://developer.android.com/studio/archive).
+   **Note**: You may try newer or older versions of Android Studio, but we can't guarantee good support.
path: wiki/Installing-Oppia-Android.md
user: login: adhiamboperes
body: Added an explanation.
created_at: 2025-03-26T22:56:20Z
author_association: CONTRIBUTOR
diff_hunk: @@ -40,20 +330,17 @@ Please follow these steps to set up Oppia Android on your local machine.
 
    **Note**: Please keep the folder name as `oppia-android`. Changing the project folder name might lead to future issues with running the pre-push checks on your machine.
 
-2. Run the `bash scripts/setup.sh` script, which adds some development tools for Oppia Android (ktlint, checkstyle, etc.): These tools perform pre-push checks to ensure that your code is properly formatted as per Oppia standards.
+2. Run the `bash scripts/setup.sh` script, which adds some development tools for Oppia Android (ktlint, checkstyle, etc.). You should see a message indicating that the various tools have been downloaded.
 
path: wiki/Installing-Oppia-Android.md
user: login: adhiamboperes
body: I'm not sure about this. Git and  bash are available by default on Mac and Linux, and the windows set up steps outline how to set them both up.

I am not opposed to adding a point to the`Troubleshooting Installation` section below, once we can clarify some common causes, stacktraces and verified solutions. Do you mind openning a discussion for this? 
created_at: 2025-03-26T23:00:34Z
author_association: CONTRIBUTOR
diff_hunk: @@ -5,32 +5,322 @@ This wiki page explains how to install Oppia Android on your local machine. If y
 ## Table of Contents
 
 - [Prepare developer environment](#prepare-developer-environment)
+- [Install Bazel](#install-bazel)
+  - [Bazel Set up for Mac](#bazel-set-up-for-mac)
+  - [Bazel Set up for Linux](#bazel-set-up-for-linux)
+  - [Bazel Set up for Windows](#bazel-set-up-for-windows)
 - [Install oppia-android](#install-oppia-android)
-- [Run the app from Android Studio](#run-the-app-from-android-studio)
+- [Opening the Project in Android Studio](#opening-the-project-in-android-studio)
 - [Set up and Run tests](#set-up-and-run-tests)
-  - [Step-by-Step guidance for setting up and running app modules robolectric test](#step-by-step-guidance-for-setting-up-and-running-app-modules-robolectric-test)
-  - [For tests that are in non-app modules, such as **domain** or **utility**:](#for-tests-that-are-in-non-app-modules-such-as-domain-or-utility)
-
+  - [Running app module tests](#running-app-module-tests)
+  - [Running non-app module tests](#running-non-app-module-tests)
+- [Next Steps](#next-steps)
+- [Troubleshooting Installation](#troubleshooting-installation)
 
 ## Prepare developer environment
 
-1. Download/Install [Android Studio Bumblebee | Patch 3](https://developer.android.com/studio/archive).
+1. Download and install Android Studio **Giraffe** from [this location](https://developer.android.com/studio/archive).
+   **Note**: You may try newer or older versions of Android Studio, but we can't guarantee good support.
 
-   **Note**: We recommend installing **Android Studio Bumblebee | 2021.1.1 Patch 3** because newer versions of Android Studio[ do not support running tests where shared source sets are used](https://issuetracker.google.com/issues/232007221#comment18), a configuration we use at Oppia.
+2. Configure your Android Studio
+   - From your PC's application menu, open Android Studio. 
+   - On the welcome screen, find the "more options menu" and select **SDK Manager**
+     
+     <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/efcc4e6e-b6ba-44fc-9c96-aa381de83911" />
+    
+   - In the "SDK Platforms" tab (which is the default), select `API Level 30` and also `API Level 34`.
+   - Also, navigate to the "SDK Tools" tab, click the "Show Package Details" checkbox at the bottom right, then click on "Android SDK Build-Tools 34-rc1" and select 32.0.0 (this is needed for Bazel support).
 
-   **Direct download Url**: [Windows](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-windows.exe) | [Linux](https://redirector.gvt1.com/edgedl/android/studio/ide-zips/2021.1.1.23/android-studio-2021.1.1.23-linux.tar.gz) | [Intel Mac](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-mac.dmg) | [Apple Silicon Mac](https://redirector.gvt1.com/edgedl/android/studio/install/2021.1.1.23/android-studio-2021.1.1.23-mac_arm.dmg)
+   - Then, click "Apply" to download and install these two SDKs/Tools.
+     - On this screen, note the **Android SDK Location**, which is set as the ANDROID_HOME variable in the Bazel setup step below.
 
-   You can have multiple versions of Android Studio installed on your machine at the same time.
+3. Prepare a test device
+   You require a physical Android device or an Android emulator to run the Oppia app. 
+   - Physical devices are useful for a real-user experience feel, and testing with [accessibility tools](https://github.com/oppia/oppia-android/wiki/Accessibility-A11y-Guide#setting-up-accessibility-scanner-and-talkback).
+   
+     **Set up a physical device for development**
+      - On the device, open the **Settings** app, select **Developer options**, and then **enable USB debugging** (if applicable).
+        - If you don't see **Developer options**, you might need to enable developer mode first. Follow [these instructions](https://developer.android.com/studio/debug/dev-options#enable) to do so.
+        - Connect to your device using USB.
+        - Verify that your device is connected by running the `adb devices` command from your terminal.
+   
+      - Emulators provide the flexibility of testing the application on a variety of devices and Android API levels without needing to have each physical device.
+   
+     **Set up an Emulator**
+      - For the best experience, you should use the emulator in Android Studio on a computer with at least the following specs:
+        - 16 GB RAM
+        - 64-bit Windows 10 or higher, MacOS 12 or higher, Linux, or ChromeOS operating system
+        - 16 GB disk space
+     
+      - If you don't have these specs, the emulator might still run but not smoothly. In this case, consider testing on a physical device.
 
-2. Configure your Android Studio
-   - In Android Studio, open Tools > SDK Manager.
-     - In the "SDK Platforms" tab (which is the default), select `API Level 28` and also `API Level 30` (for Bazel support).
-     - Also, navigate to the "SDK Tools" tab, click the "Show Package Details" checkbox at the bottom right, then click on "Android SDK Build-Tools 34-rc1" and select 32.0.0 (this is needed for Bazel support).
+      - On the welcome screen, find the "more options menu" and select **Virtual Device Manager**
+     
+        <img width="1029" alt="Image" src="https://github.com/user-attachments/assets/efcc4e6e-b6ba-44fc-9c96-aa381de83911" />
+         
+        * If you already have a project open in Android Studio, in the right hand toolbar, locate `device Manager`.
+      - Click the **+**, and then click **Create Virtual Device**.
+      - Follow the wizard to create a phone and a tablet AVD, setting the **system image** to be one of `API Level 30` or `API Level 34` as installed above.
+      - After creating your devices, you will be able to see a list of all the devices on the device manager panel.
+      - For more information on the different configurations available for AVDs, please visit the [official documentation page.](https://developer.android.com/studio/run/managing-avds)
 
-   - Then, click "Apply" to download and install these two SDKs/Tools.
+## Install Bazel
+### Instructions
+
+**The steps to setting up Bazel are:**
+1. Install Bazel
+2. Set Bazel and ANDROID_HOME paths permanently in your terminal
+3. Verify that the build is working
+
+The expected output of `bazel --version` once Bazel set up is successful is:
+
+```
+bazel 6.5.0
+```
+
+### Bazel Set up for Mac
+It is recommended to use the binary installer steps outline below. For other ways to install Bazel on Mac, refer to the [official page](https://bazel.build/install/os-x).
+
+**Step 1: Install Xcode command line tools**
+
+In macOS 14 or earlier, it is sufficient to install the Xcode command line tools package by using xcode-select:
+
+```
+xcode-select --install
+```
+
+Otherwise, for macOS 15 and later, you must have Xcode 6.1 or later installed on your system.
+
+Download Xcode from the [App Store](https://apps.apple.com/us/app/xcode/id497799835) or the [Apple Developer site](https://developer.apple.com/download/more/?=xcode).
+
+Once Xcode is installed, accept the license agreement for all users with the following command:
+
+```
+sudo xcodebuild -license accept
+```
+
+**Step 2: Download the Bazel installer**
+
+Click [here](https://github.com/bazelbuild/bazel/releases/download/6.5.0/bazel-6.5.0-installer-darwin-x86_64.sh) to download the Bazel 6.5.0 binary installer.
+
+**Step 3: Run the installer**
+
+Run the Bazel installer as follows:
+
+```shell
+chmod +x "bazel-6.5.0-installer-darwin-x86_64.sh"
+./bazel-6.5.0-installer-darwin-x86_64.sh --user
+```
+
+**Step 4: Set up your environment**
+
+You must set the path for `Bazel` and `ANDROID_HOME` before running bazel build for oppia-android, otherwise you will get an error.
+
+If you ran the Bazel installer with the `--user` flag as above, the Bazel executable is installed in your $HOME/bin directory. It’s a good idea to add this directory to your default paths, as follows:
+
+```shell
+export PATH="$PATH:$HOME/bin"
+```
+
+To set the `ANDROID_HOME` path permanently in your terminal run these commands:
+
+```
+sudo nano /etc/paths
+```
+- Enter your password, when prompted.
+- Go to the bottom of the file, and enter this path: `$HOME/Library/Android/sdk`
+- Hit control-x to quit.
+- Enter “Y” to save the modified buffer.
+- That’s it! To test it, in a new terminal window, type: `echo $PATH`
+
+**Step 5: Verify that the build is working**
+
+Run the following command in your terminal:
+
+```
+bazel --version
+```
+
+### Bazel Set up for Linux
+This section covers Bazel installation on Ubuntu. 
+
+Recommendations:
+- use Ubuntu 18.04 (LTS), 20.04 (LTS), or 22.04 (LTS).
+- use ``apt`` installation instructions.
+
+- **Note**: if you encounter any errors related to `cURL`, please set up cURL on your machine using `sudo apt install curl`.
+
+**Step 1: Add Bazel distribution URI as a package source**
+
+This is a one-time setup step.
+
+```
+sudo apt install apt-transport-https curl gnupg -y
+curl -fsSL https://bazel.build/bazel-release.pub.gpg | gpg --dearmor >bazel-archive-keyring.gpg
+sudo mv bazel-archive-keyring.gpg /usr/share/keyrings
+echo "deb [arch=amd64 signed-by=/usr/share/keyrings/bazel-archive-keyring.gpg] https://storage.googleapis.com/bazel-apt stable jdk1.8" | sudo tee /etc/apt/sources.list.d/bazel.list
+```
+
+**Step 2: Install and update Bazel**
+
+Run:
+```shell
+sudo apt-get update && sudo apt-get install bazel-6.5.0
+```
+
+**Step 3: Set up your environment**
+
+Ensure that your `ANDROID_HOME` environment variable is set to the location of your Android SDK. Assuming the SDK is installed to default locations, you can use the following commands to set the `ANDROID_HOME` variable:
+
+```
+export ANDROID_HOME=$HOME/Android/Sdk/
+```
+
+**Step 4: Verify that the build is working**
+
+Run the following command in your terminal:
+
+```
+bazel --version
+```
+
+### Bazel Set up for Windows
+This page outlines one way to allow Bazel to be used in CLI form on Windows. Please note that **this support is currently experimental**. We suggest that you post a discussion at [github-discussions](https://github.com/oppia/oppia-android/discussions/categories/q-a-installation) if you run into any problems.
+
+Unlike Unix-based systems where Bazel runs natively without issue, the current solution on Windows is to install an Ubuntu-based subsystem. Windows currently only supports a terminal experience in this subsystem (though there is a prerelease version of the software with GUI support) which means Android Studio will not be supported. You will need to continue using the Windows version of Android Studio and only use the Linux subsystem for building & running Robolectric or JUnit-based tests.
+
+Due to the issues mentioned above, we recommend dual-booting your PC with Linux. However, if you choose to use Windows, please follow the instructions below:
path: wiki/Installing-Oppia-Android.md
user: login: adhiamboperes
body: Changes made.
created_at: 2025-03-26T23:01:53Z
author_association: CONTRIBUTOR
diff_hunk: @@ -0,0 +1,284 @@
+## Table of Contents
+
+- [Overview](#overview)
+- [Installation](#installation)
+  - [Building the app](#building-the-app)
+- [Running Tests](#running-tests)
+  - [How to Obtain a Test Target](#how-to-obtain-a-test-target)
+  - [Common Flags](#common-flags)
+  - [Running multiple test targets](#running-multiple-test-targets)
+- [Concepts and Terminology](#concepts-and-terminology)
+- [Syncing the Project](#syncing-the-project)
+
+## Overview
+Bazel is an open-source build and test tool similar to Make, Maven, and Gradle. It uses a human-readable, high-level build language.
path: wiki/Bazel-User-Guide.md
user: login: adhiamboperes
body: Done
created_at: 2025-03-26T23:04:08Z
author_association: CONTRIBUTOR
diff_hunk: @@ -40,20 +330,17 @@ Please follow these steps to set up Oppia Android on your local machine.
 
    **Note**: Please keep the folder name as `oppia-android`. Changing the project folder name might lead to future issues with running the pre-push checks on your machine.
 
-2. Run the `bash scripts/setup.sh` script, which adds some development tools for Oppia Android (ktlint, checkstyle, etc.): These tools perform pre-push checks to ensure that your code is properly formatted as per Oppia standards.
+2. Run the `bash scripts/setup.sh` script, which adds some development tools for Oppia Android (ktlint, checkstyle, etc.). You should see a message indicating that the various tools have been downloaded.
 
path: wiki/Installing-Oppia-Android.md
user: login: adhiamboperes
body: I'd like to resolve this since it is technically non-blocking. Please let us follow up in a discussion/issue.
created_at: 2025-03-26T23:07:18Z
author_association: CONTRIBUTOR

PR comments:
user: login: github-actions[bot]
created_at: 2025-02-26T20:21:50Z
body: ## Coverage Report
### Results
Coverage Analysis: **SKIP** :next_track_button:

_This PR did not introduce any changes to Kotlin source or test files._

#
>To learn more, visit the [Oppia Android Code Coverage](https://github.com/oppia/oppia-android/wiki/Oppia-Android-Code-Coverage) wiki page
author_association: NONE
user: login: github-actions[bot]
created_at: 2025-02-27T02:52:56Z
body: # APK & AAB differences analysis
Note that this is a summarized snapshot. See the CI artifacts for detailed differences.

## Dev

<details><summary>Expand to see flavor specifics</summary>

### Universal APK
APK file size: 19 MiB (old), 19 MiB (new), **4 bytes** (Removed)

APK download size (estimated): 17 MiB (old), 17 MiB (new), **36 bytes** (Added)

Method count: 260308 (old), 260308 (new), **0** (No change)

Features: 2 (old), 2 (new), **0** (No change)

Permissions: 6 (old), 6 (new), **0** (No change)

Resources: 6832 (old), 6832 (new), **0** (No change)
- Anim: 43 (old), 43 (new), **0** (No change)
- Animator: 26 (old), 26 (new), **0** (No change)
- Array: 15 (old), 15 (new), **0** (No change)
- Attr: 922 (old), 922 (new), **0** (No change)
- Bool: 9 (old), 9 (new), **0** (No change)
- Color: 967 (old), 967 (new), **0** (No change)
- Dimen: 1048 (old), 1048 (new), **0** (No change)
- Drawable: 380 (old), 380 (new), **0** (No change)
- Id: 1285 (old), 1285 (new), **0** (No change)
- Integer: 37 (old), 37 (new), **0** (No change)
- Interpolator: 11 (old), 11 (new), **0** (No change)
- Layout: 380 (old), 380 (new), **0** (No change)
- Menu: 3 (old), 3 (new), **0** (No change)
- Mipmap: 1 (old), 1 (new), **0** (No change)
- Plurals: 10 (old), 10 (new), **0** (No change)
- Raw: 2 (old), 2 (new), **0** (No change)
- String: 855 (old), 855 (new), **0** (No change)
- Style: 832 (old), 832 (new), **0** (No change)
- Xml: 6 (old), 6 (new), **0** (No change)

Lesson assets: 111 (old), 111 (new), **0** (No change)

### AAB differences
<details><summary>Expand to see AAB specifics</summary>

Supported configurations:
- hdpi (same)
- ldpi (same)
- mdpi (same)
- tvdpi (same)
- xhdpi (same)
- xxhdpi (same)
- xxxhdpi (same)

#### Base APK
APK file size: 18 MiB (old), 18 MiB (new), **4 bytes** (Removed)
APK download size (estimated): 17 MiB (old), 17 MiB (new), **10 bytes** (Removed)

#### Configuration hdpi
APK file size: 50 KiB (old), 50 KiB (new), **0 bytes** (No change)
APK download size (estimated): 18 KiB (old), 18 KiB (new), **0 bytes** (No change)

#### Configuration ldpi
APK file size: 49 KiB (old), 49 KiB (new), **0 bytes** (No change)
APK download size (estimated): 14 KiB (old), 14 KiB (new), **0 bytes** (No change)

#### Configuration mdpi
APK file size: 45 KiB (old), 45 KiB (new), **0 bytes** (No change)
APK download size (estimated): 14 KiB (old), 14 KiB (new), **0 bytes** (No change)

#### Configuration tvdpi
APK file size: 86 KiB (old), 86 KiB (new), **0 bytes** (No change)
APK download size (estimated): 29 KiB (old), 29 KiB (new), **0 bytes** (No change)

#### Configuration xhdpi
APK file size: 57 KiB (old), 57 KiB (new), **0 bytes** (No change)
APK download size (estimated): 21 KiB (old), 21 KiB (new), **0 bytes** (No change)

#### Configuration xxhdpi
APK file size: 63 KiB (old), 63 KiB (new), **0 bytes** (No change)
APK download size (estimated): 29 KiB (old), 29 KiB (new), **0 bytes** (No change)

#### Configuration xxxhdpi
APK file size: 63 KiB (old), 63 KiB (new), **0 bytes** (No change)
APK download size (estimated): 28 KiB (old), 28 KiB (new), **0 bytes** (No change)
</details></details>

## Alpha

<details><summary>Expand to see flavor specifics</summary>

### Universal APK
APK file size: 11 MiB (old), 11 MiB (new), **4 bytes** (Removed)

APK download size (estimated): 10 MiB (old), 10 MiB (new), **28 bytes** (Removed)

Method count: 115790 (old), 115790 (new), **0** (No change)

Features: 2 (old), 2 (new), **0** (No change)

Permissions: 6 (old), 6 (new), **0** (No change)

Resources: 5800 (old), 5800 (new), **0** (No change)
- Anim: 33 (old), 33 (new), **0** (No change)
- Animator: 24 (old), 24 (new), **0** (No change)
- Array: 14 (old), 14 (new), **0** (No change)
- Attr: 888 (old), 888 (new), **0** (No change)
- Bool: 8 (old), 8 (new), **0** (No change)
- Color: 820 (old), 820 (new), **0** (No change)
- Dimen: 780 (old), 780 (new), **0** (No change)
- Drawable: 342 (old), 342 (new), **0** (No change)
- Id: 1231 (old), 1231 (new), **0** (No change)
- Integer: 32 (old), 32 (new), **0** (No change)
- Interpolator: 11 (old), 11 (new), **0** (No change)
- Layout: 343 (old), 343 (new), **0** (No change)
- Menu: 1 (old), 1 (new), **0** (No change)
- Mipmap: 1 (old), 1 (new), **0** (No change)
- Plurals: 10 (old), 10 (new), **0** (No change)
- String: 788 (old), 788 (new), **0** (No change)
- Style: 473 (old), 473 (new), **0** (No change)
- Xml: 1 (old), 1 (new), **0** (No change)

Lesson assets: 111 (old), 111 (new), **0** (No change)

### AAB differences
<details><summary>Expand to see AAB specifics</summary>

Supported configurations:
- hdpi (same)
- ldpi (same)
- mdpi (same)
- tvdpi (same)
- xhdpi (same)
- xxhdpi (same)
- xxxhdpi (same)

#### Base APK
APK file size: 11 MiB (old), 11 MiB (new), **4 bytes** (Removed)
APK download size (estimated): 10 MiB (old), 10 MiB (new), **7 bytes** (Added)

#### Configuration hdpi
APK file size: 43 KiB (old), 43 KiB (new), **0 bytes** (No change)
APK download size (estimated): 17 KiB (old), 17 KiB (new), **0 bytes** (No change)

#### Configuration ldpi
APK file size: 44 KiB (old), 44 KiB (new), **0 bytes** (No change)
APK download size (estimated): 13 KiB (old), 13 KiB (new), **0 bytes** (No change)

#### Configuration mdpi
APK file size: 38 KiB (old), 38 KiB (new), **0 bytes** (No change)
APK download size (estimated): 13 KiB (old), 13 KiB (new), **0 bytes** (No change)

#### Configuration tvdpi
APK file size: 73 KiB (old), 73 KiB (new), **0 bytes** (No change)
APK download size (estimated): 27 KiB (old), 27 KiB (new), **0 bytes** (No change)

#### Configuration xhdpi
APK file size: 50 KiB (old), 50 KiB (new), **0 bytes** (No change)
APK download size (estimated): 20 KiB (old), 20 KiB (new), **0 bytes** (No change)

#### Configuration xxhdpi
APK file size: 55 KiB (old), 55 KiB (new), **0 bytes** (No change)
APK download size (estimated): 28 KiB (old), 28 KiB (new), **0 bytes** (No change)

#### Configuration xxxhdpi
APK file size: 55 KiB (old), 55 KiB (new), **0 bytes** (No change)
APK download size (estimated): 27 KiB (old), 27 KiB (new), **0 bytes** (No change)
</details></details>

## Beta

<details><summary>Expand to see flavor specifics</summary>

### Universal APK
APK file size: 11 MiB (old), 11 MiB (new), **0 bytes** (No change)

APK download size (estimated): 10 MiB (old), 10 MiB (new), **8 bytes** (Added)

Method count: 115796 (old), 115796 (new), **0** (No change)

Features: 2 (old), 2 (new), **0** (No change)

Permissions: 6 (old), 6 (new), **0** (No change)

Resources: 5800 (old), 5800 (new), **0** (No change)
- Anim: 33 (old), 33 (new), **0** (No change)
- Animator: 24 (old), 24 (new), **0** (No change)
- Array: 14 (old), 14 (new), **0** (No change)
- Attr: 888 (old), 888 (new), **0** (No change)
- Bool: 8 (old), 8 (new), **0** (No change)
- Color: 820 (old), 820 (new), **0** (No change)
- Dimen: 780 (old), 780 (new), **0** (No change)
- Drawable: 342 (old), 342 (new), **0** (No change)
- Id: 1231 (old), 1231 (new), **0** (No change)
- Integer: 32 (old), 32 (new), **0** (No change)
- Interpolator: 11 (old), 11 (new), **0** (No change)
- Layout: 343 (old), 343 (new), **0** (No change)
- Menu: 1 (old), 1 (new), **0** (No change)
- Mipmap: 1 (old), 1 (new), **0** (No change)
- Plurals: 10 (old), 10 (new), **0** (No change)
- String: 788 (old), 788 (new), **0** (No change)
- Style: 473 (old), 473 (new), **0** (No change)
- Xml: 1 (old), 1 (new), **0** (No change)

Lesson assets: 111 (old), 111 (new), **0** (No change)

### AAB differences
<details><summary>Expand to see AAB specifics</summary>

Supported configurations:
- hdpi (same)
- ldpi (same)
- mdpi (same)
- tvdpi (same)
- xhdpi (same)
- xxhdpi (same)
- xxxhdpi (same)

#### Base APK
APK file size: 10 MiB (old), 10 MiB (new), **0 bytes** (No change)
APK download size (estimated): 9 MiB (old), 9 MiB (new), **8 bytes** (Removed)

#### Configuration hdpi
APK file size: 43 KiB (old), 43 KiB (new), **0 bytes** (No change)
APK download size (estimated): 17 KiB (old), 17 KiB (new), **0 bytes** (No change)

#### Configuration ldpi
APK file size: 44 KiB (old), 44 KiB (new), **0 bytes** (No change)
APK download size (estimated): 13 KiB (old), 13 KiB (new), **0 bytes** (No change)

#### Configuration mdpi
APK file size: 38 KiB (old), 38 KiB (new), **0 bytes** (No change)
APK download size (estimated): 13 KiB (old), 13 KiB (new), **0 bytes** (No change)

#### Configuration tvdpi
APK file size: 73 KiB (old), 73 KiB (new), **0 bytes** (No change)
APK download size (estimated): 27 KiB (old), 27 KiB (new), **0 bytes** (No change)

#### Configuration xhdpi
APK file size: 50 KiB (old), 50 KiB (new), **0 bytes** (No change)
APK download size (estimated): 20 KiB (old), 20 KiB (new), **0 bytes** (No change)

#### Configuration xxhdpi
APK file size: 55 KiB (old), 55 KiB (new), **0 bytes** (No change)
APK download size (estimated): 28 KiB (old), 28 KiB (new), **0 bytes** (No change)

#### Configuration xxxhdpi
APK file size: 55 KiB (old), 55 KiB (new), **0 bytes** (No change)
APK download size (estimated): 27 KiB (old), 27 KiB (new), **0 bytes** (No change)
</details></details>

## Ga

<details><summary>Expand to see flavor specifics</summary>

### Universal APK
APK file size: 11 MiB (old), 11 MiB (new), **0 bytes** (No change)

APK download size (estimated): 10 MiB (old), 10 MiB (new), **14 bytes** (Added)

Method count: 115796 (old), 115796 (new), **0** (No change)

Features: 2 (old), 2 (new), **0** (No change)

Permissions: 6 (old), 6 (new), **0** (No change)

Resources: 5800 (old), 5800 (new), **0** (No change)
- Anim: 33 (old), 33 (new), **0** (No change)
- Animator: 24 (old), 24 (new), **0** (No change)
- Array: 14 (old), 14 (new), **0** (No change)
- Attr: 888 (old), 888 (new), **0** (No change)
- Bool: 8 (old), 8 (new), **0** (No change)
- Color: 820 (old), 820 (new), **0** (No change)
- Dimen: 780 (old), 780 (new), **0** (No change)
- Drawable: 342 (old), 342 (new), **0** (No change)
- Id: 1231 (old), 1231 (new), **0** (No change)
- Integer: 32 (old), 32 (new), **0** (No change)
- Interpolator: 11 (old), 11 (new), **0** (No change)
- Layout: 343 (old), 343 (new), **0** (No change)
- Menu: 1 (old), 1 (new), **0** (No change)
- Mipmap: 1 (old), 1 (new), **0** (No change)
- Plurals: 10 (old), 10 (new), **0** (No change)
- String: 788 (old), 788 (new), **0** (No change)
- Style: 473 (old), 473 (new), **0** (No change)
- Xml: 1 (old), 1 (new), **0** (No change)

Lesson assets: 111 (old), 111 (new), **0** (No change)

### AAB differences
<details><summary>Expand to see AAB specifics</summary>

Supported configurations:
- hdpi (same)
- ldpi (same)
- mdpi (same)
- tvdpi (same)
- xhdpi (same)
- xxhdpi (same)
- xxxhdpi (same)

#### Base APK
APK file size: 10 MiB (old), 10 MiB (new), **0 bytes** (No change)
APK download size (estimated): 9 MiB (old), 9 MiB (new), **7 bytes** (Added)

#### Configuration hdpi
APK file size: 43 KiB (old), 43 KiB (new), **0 bytes** (No change)
APK download size (estimated): 17 KiB (old), 17 KiB (new), **0 bytes** (No change)

#### Configuration ldpi
APK file size: 44 KiB (old), 44 KiB (new), **0 bytes** (No change)
APK download size (estimated): 13 KiB (old), 13 KiB (new), **0 bytes** (No change)

#### Configuration mdpi
APK file size: 38 KiB (old), 38 KiB (new), **0 bytes** (No change)
APK download size (estimated): 13 KiB (old), 13 KiB (new), **0 bytes** (No change)

#### Configuration tvdpi
APK file size: 73 KiB (old), 73 KiB (new), **0 bytes** (No change)
APK download size (estimated): 27 KiB (old), 27 KiB (new), **0 bytes** (No change)

#### Configuration xhdpi
APK file size: 50 KiB (old), 50 KiB (new), **0 bytes** (No change)
APK download size (estimated): 20 KiB (old), 20 KiB (new), **0 bytes** (No change)

#### Configuration xxhdpi
APK file size: 55 KiB (old), 55 KiB (new), **0 bytes** (No change)
APK download size (estimated): 28 KiB (old), 28 KiB (new), **0 bytes** (No change)

#### Configuration xxxhdpi
APK file size: 55 KiB (old), 55 KiB (new), **0 bytes** (No change)
APK download size (estimated): 27 KiB (old), 27 KiB (new), **0 bytes** (No change)
</details></details>
author_association: NONE
user: login: adhiamboperes
created_at: 2025-02-28T11:10:30Z
body: @manas-yu, could you PTAL at this PR? I have made some changes that need to be reviewed based on:
 - Are they clear, or do we need to paraphrase some sentences?
 - Are they easy to follow?
 - Are there any grammatical errors?
 The sections in red are deletions, and green are additions.

Ps - you can switch to rich diff on the top right of each file to see the MD formatted version.

@BenHenning, could you PTAL for completeness? 
author_association: CONTRIBUTOR
user: login: github-actions[bot]
created_at: 2025-03-01T02:54:57Z
body: # APK & AAB differences analysis
Note that this is a summarized snapshot. See the CI artifacts for detailed differences.

## Dev

<details><summary>Expand to see flavor specifics</summary>

### Universal APK
APK file size: 19 MiB (old), 19 MiB (new), **4 bytes** (Removed)

APK download size (estimated): 17 MiB (old), 17 MiB (new), **19 bytes** (Added)

Method count: 260308 (old), 260308 (new), **0** (No change)

Features: 2 (old), 2 (new), **0** (No change)

Permissions: 6 (old), 6 (new), **0** (No change)

Resources: 6832 (old), 6832 (new), **0** (No change)
- Anim: 43 (old), 43 (new), **0** (No change)
- Animator: 26 (old), 26 (new), **0** (No change)
- Array: 15 (old), 15 (new), **0** (No change)
- Attr: 922 (old), 922 (new), **0** (No change)
- Bool: 9 (old), 9 (new), **0** (No change)
- Color: 967 (old), 967 (new), **0** (No change)
- Dimen: 1048 (old), 1048 (new), **0** (No change)
- Drawable: 380 (old), 380 (new), **0** (No change)
- Id: 1285 (old), 1285 (new), **0** (No change)
- Integer: 37 (old), 37 (new), **0** (No change)
- Interpolator: 11 (old), 11 (new), **0** (No change)
- Layout: 380 (old), 380 (new), **0** (No change)
- Menu: 3 (old), 3 (new), **0** (No change)
- Mipmap: 1 (old), 1 (new), **0** (No change)
- Plurals: 10 (old), 10 (new), **0** (No change)
- Raw: 2 (old), 2 (new), **0** (No change)
- String: 855 (old), 855 (new), **0** (No change)
- Style: 832 (old), 832 (new), **0** (No change)
- Xml: 6 (old), 6 (new), **0** (No change)

Lesson assets: 111 (old), 111 (new), **0** (No change)

### AAB differences
<details><summary>Expand to see AAB specifics</summary>

Supported configurations:
- hdpi (same)
- ldpi (same)
- mdpi (same)
- tvdpi (same)
- xhdpi (same)
- xxhdpi (same)
- xxxhdpi (same)

#### Base APK
APK file size: 18 MiB (old), 18 MiB (new), **4 bytes** (Removed)
APK download size (estimated): 17 MiB (old), 17 MiB (new), **9 bytes** (Removed)

#### Configuration hdpi
APK file size: 50 KiB (old), 50 KiB (new), **0 bytes** (No change)
APK download size (estimated): 18 KiB (old), 18 KiB (new), **0 bytes** (No change)

#### Configuration ldpi
APK file size: 49 KiB (old), 49 KiB (new), **0 bytes** (No change)
APK download size (estimated): 14 KiB (old), 14 KiB (new), **0 bytes** (No change)

#### Configuration mdpi
APK file size: 45 KiB (old), 45 KiB (new), **0 bytes** (No change)
APK download size (estimated): 14 KiB (old), 14 KiB (new), **0 bytes** (No change)

#### Configuration tvdpi
APK file size: 86 KiB (old), 86 KiB (new), **0 bytes** (No change)
APK download size (estimated): 29 KiB (old), 29 KiB (new), **0 bytes** (No change)

#### Configuration xhdpi
APK file size: 57 KiB (old), 57 KiB (new), **0 bytes** (No change)
APK download size (estimated): 21 KiB (old), 21 KiB (new), **0 bytes** (No change)

#### Configuration xxhdpi
APK file size: 63 KiB (old), 63 KiB (new), **0 bytes** (No change)
APK download size (estimated): 29 KiB (old), 29 KiB (new), **0 bytes** (No change)

#### Configuration xxxhdpi
APK file size: 63 KiB (old), 63 KiB (new), **0 bytes** (No change)
APK download size (estimated): 28 KiB (old), 28 KiB (new), **0 bytes** (No change)
</details></details>

## Alpha

<details><summary>Expand to see flavor specifics</summary>

### Universal APK
APK file size: 11 MiB (old), 11 MiB (new), **8 bytes** (Removed)

APK download size (estimated): 10 MiB (old), 10 MiB (new), **18 bytes** (Added)

Method count: 115790 (old), 115790 (new), **0** (No change)

Features: 2 (old), 2 (new), **0** (No change)

Permissions: 6 (old), 6 (new), **0** (No change)

Resources: 5800 (old), 5800 (new), **0** (No change)
- Anim: 33 (old), 33 (new), **0** (No change)
- Animator: 24 (old), 24 (new), **0** (No change)
- Array: 14 (old), 14 (new), **0** (No change)
- Attr: 888 (old), 888 (new), **0** (No change)
- Bool: 8 (old), 8 (new), **0** (No change)
- Color: 820 (old), 820 (new), **0** (No change)
- Dimen: 780 (old), 780 (new), **0** (No change)
- Drawable: 342 (old), 342 (new), **0** (No change)
- Id: 1231 (old), 1231 (new), **0** (No change)
- Integer: 32 (old), 32 (new), **0** (No change)
- Interpolator: 11 (old), 11 (new), **0** (No change)
- Layout: 343 (old), 343 (new), **0** (No change)
- Menu: 1 (old), 1 (new), **0** (No change)
- Mipmap: 1 (old), 1 (new), **0** (No change)
- Plurals: 10 (old), 10 (new), **0** (No change)
- String: 788 (old), 788 (new), **0** (No change)
- Style: 473 (old), 473 (new), **0** (No change)
- Xml: 1 (old), 1 (new), **0** (No change)

Lesson assets: 111 (old), 111 (new), **0** (No change)

### AAB differences
<details><summary>Expand to see AAB specifics</summary>

Supported configurations:
- hdpi (same)
- ldpi (same)
- mdpi (same)
- tvdpi (same)
- xhdpi (same)
- xxhdpi (same)
- xxxhdpi (same)

#### Base APK
APK file size: 11 MiB (old), 11 MiB (new), **4 bytes** (Removed)
APK download size (estimated): 10 MiB (old), 10 MiB (new), **20 bytes** (Removed)

#### Configuration hdpi
APK file size: 43 KiB (old), 43 KiB (new), **0 bytes** (No change)
APK download size (estimated): 17 KiB (old), 17 KiB (new), **0 bytes** (No change)

#### Configuration ldpi
APK file size: 44 KiB (old), 44 KiB (new), **0 bytes** (No change)
APK download size (estimated): 13 KiB (old), 13 KiB (new), **0 bytes** (No change)

#### Configuration mdpi
APK file size: 38 KiB (old), 38 KiB (new), **0 bytes** (No change)
APK download size (estimated): 13 KiB (old), 13 KiB (new), **0 bytes** (No change)

#### Configuration tvdpi
APK file size: 73 KiB (old), 73 KiB (new), **0 bytes** (No change)
APK download size (estimated): 27 KiB (old), 27 KiB (new), **0 bytes** (No change)

#### Configuration xhdpi
APK file size: 50 KiB (old), 50 KiB (new), **0 bytes** (No change)
APK download size (estimated): 20 KiB (old), 20 KiB (new), **0 bytes** (No change)

#### Configuration xxhdpi
APK file size: 55 KiB (old), 55 KiB (new), **0 bytes** (No change)
APK download size (estimated): 28 KiB (old), 28 KiB (new), **0 bytes** (No change)

#### Configuration xxxhdpi
APK file size: 55 KiB (old), 55 KiB (new), **0 bytes** (No change)
APK download size (estimated): 27 KiB (old), 27 KiB (new), **0 bytes** (No change)
</details></details>

## Beta

<details><summary>Expand to see flavor specifics</summary>

### Universal APK
APK file size: 11 MiB (old), 11 MiB (new), **0 bytes** (No change)

APK download size (estimated): 10 MiB (old), 10 MiB (new), **10 bytes** (Added)

Method count: 115796 (old), 115796 (new), **0** (No change)

Features: 2 (old), 2 (new), **0** (No change)

Permissions: 6 (old), 6 (new), **0** (No change)

Resources: 5800 (old), 5800 (new), **0** (No change)
- Anim: 33 (old), 33 (new), **0** (No change)
- Animator: 24 (old), 24 (new), **0** (No change)
- Array: 14 (old), 14 (new), **0** (No change)
- Attr: 888 (old), 888 (new), **0** (No change)
- Bool: 8 (old), 8 (new), **0** (No change)
- Color: 820 (old), 820 (new), **0** (No change)
- Dimen: 780 (old), 780 (new), **0** (No change)
- Drawable: 342 (old), 342 (new), **0** (No change)
- Id: 1231 (old), 1231 (new), **0** (No change)
- Integer: 32 (old), 32 (new), **0** (No change)
- Interpolator: 11 (old), 11 (new), **0** (No change)
- Layout: 343 (old), 343 (new), **0** (No change)
- Menu: 1 (old), 1 (new), **0** (No change)
- Mipmap: 1 (old), 1 (new), **0** (No change)
- Plurals: 10 (old), 10 (new), **0** (No change)
- String: 788 (old), 788 (new), **0** (No change)
- Style: 473 (old), 473 (new), **0** (No change)
- Xml: 1 (old), 1 (new), **0** (No change)

Lesson assets: 111 (old), 111 (new), **0** (No change)

### AAB differences
<details><summary>Expand to see AAB specifics</summary>

Supported configurations:
- hdpi (same)
- ldpi (same)
- mdpi (same)
- tvdpi (same)
- xhdpi (same)
- xxhdpi (same)
- xxxhdpi (same)

#### Base APK
APK file size: 10 MiB (old), 10 MiB (new), **0 bytes** (No change)
APK download size (estimated): 9 MiB (old), 9 MiB (new), **23 bytes** (Removed)

#### Configuration hdpi
APK file size: 43 KiB (old), 43 KiB (new), **0 bytes** (No change)
APK download size (estimated): 17 KiB (old), 17 KiB (new), **0 bytes** (No change)

#### Configuration ldpi
APK file size: 44 KiB (old), 44 KiB (new), **0 bytes** (No change)
APK download size (estimated): 13 KiB (old), 13 KiB (new), **0 bytes** (No change)

#### Configuration mdpi
APK file size: 38 KiB (old), 38 KiB (new), **0 bytes** (No change)
APK download size (estimated): 13 KiB (old), 13 KiB (new), **0 bytes** (No change)

#### Configuration tvdpi
APK file size: 73 KiB (old), 73 KiB (new), **0 bytes** (No change)
APK download size (estimated): 27 KiB (old), 27 KiB (new), **0 bytes** (No change)

#### Configuration xhdpi
APK file size: 50 KiB (old), 50 KiB (new), **0 bytes** (No change)
APK download size (estimated): 20 KiB (old), 20 KiB (new), **0 bytes** (No change)

#### Configuration xxhdpi
APK file size: 55 KiB (old), 55 KiB (new), **0 bytes** (No change)
APK download size (estimated): 28 KiB (old), 28 KiB (new), **0 bytes** (No change)

#### Configuration xxxhdpi
APK file size: 55 KiB (old), 55 KiB (new), **0 bytes** (No change)
APK download size (estimated): 27 KiB (old), 27 KiB (new), **0 bytes** (No change)
</details></details>

## Ga

<details><summary>Expand to see flavor specifics</summary>

### Universal APK
APK file size: 11 MiB (old), 11 MiB (new), **0 bytes** (No change)

APK download size (estimated): 10 MiB (old), 10 MiB (new), **8 bytes** (Removed)

Method count: 115796 (old), 115796 (new), **0** (No change)

Features: 2 (old), 2 (new), **0** (No change)

Permissions: 6 (old), 6 (new), **0** (No change)

Resources: 5800 (old), 5800 (new), **0** (No change)
- Anim: 33 (old), 33 (new), **0** (No change)
- Animator: 24 (old), 24 (new), **0** (No change)
- Array: 14 (old), 14 (new), **0** (No change)
- Attr: 888 (old), 888 (new), **0** (No change)
- Bool: 8 (old), 8 (new), **0** (No change)
- Color: 820 (old), 820 (new), **0** (No change)
- Dimen: 780 (old), 780 (new), **0** (No change)
- Drawable: 342 (old), 342 (new), **0** (No change)
- Id: 1231 (old), 1231 (new), **0** (No change)
- Integer: 32 (old), 32 (new), **0** (No change)
- Interpolator: 11 (old), 11 (new), **0** (No change)
- Layout: 343 (old), 343 (new), **0** (No change)
- Menu: 1 (old), 1 (new), **0** (No change)
- Mipmap: 1 (old), 1 (new), **0** (No change)
- Plurals: 10 (old), 10 (new), **0** (No change)
- String: 788 (old), 788 (new), **0** (No change)
- Style: 473 (old), 473 (new), **0** (No change)
- Xml: 1 (old), 1 (new), **0** (No change)

Lesson assets: 111 (old), 111 (new), **0** (No change)

### AAB differences
<details><summary>Expand to see AAB specifics</summary>

Supported configurations:
- hdpi (same)
- ldpi (same)
- mdpi (same)
- tvdpi (same)
- xhdpi (same)
- xxhdpi (same)
- xxxhdpi (same)

#### Base APK
APK file size: 10 MiB (old), 10 MiB (new), **0 bytes** (No change)
APK download size (estimated): 9 MiB (old), 9 MiB (new), **22 bytes** (Added)

#### Configuration hdpi
APK file size: 43 KiB (old), 43 KiB (new), **0 bytes** (No change)
APK download size (estimated): 17 KiB (old), 17 KiB (new), **0 bytes** (No change)

#### Configuration ldpi
APK file size: 44 KiB (old), 44 KiB (new), **0 bytes** (No change)
APK download size (estimated): 13 KiB (old), 13 KiB (new), **0 bytes** (No change)

#### Configuration mdpi
APK file size: 38 KiB (old), 38 KiB (new), **0 bytes** (No change)
APK download size (estimated): 13 KiB (old), 13 KiB (new), **0 bytes** (No change)

#### Configuration tvdpi
APK file size: 73 KiB (old), 73 KiB (new), **0 bytes** (No change)
APK download size (estimated): 27 KiB (old), 27 KiB (new), **0 bytes** (No change)

#### Configuration xhdpi
APK file size: 50 KiB (old), 50 KiB (new), **0 bytes** (No change)
APK download size (estimated): 20 KiB (old), 20 KiB (new), **0 bytes** (No change)

#### Configuration xxhdpi
APK file size: 55 KiB (old), 55 KiB (new), **0 bytes** (No change)
APK download size (estimated): 28 KiB (old), 28 KiB (new), **0 bytes** (No change)

#### Configuration xxxhdpi
APK file size: 55 KiB (old), 55 KiB (new), **0 bytes** (No change)
APK download size (estimated): 27 KiB (old), 27 KiB (new), **0 bytes** (No change)
</details></details>
author_association: NONE
user: login: BenHenning
created_at: 2025-03-04T19:40:01Z
body: Thanks @adhiamboperes. Been trying, and failing, to get to this so I'm very happy to see that you were able to make some time to get this situation better.

I will take a look for content soon, but one thought: could we maybe consolidate all starting documentation to just a single location? It's currently confusing that it's so split up, and now that we're using Bazel the differences between the different platform setups seem less significant. Suggestions:
- Revamp the installation page to cover both app install & Bazel setup instructions. Any platform-specific stuff should be added as subsections there (but keep common stuff together so we don't need to update copies of information).
- Consolidate installation issues to the installation page rather than having a separate one.
- Move known Bazel issues to the installation issues list from the contributing page.
- Remove the contributing page's sections on Bazel migration and installing the Oppia web app (we don't need the latter).
- Please make sure there aren't references to the old installation pages anywhere in code or the wiki pages. It'd be nice to do a redirect, but as far as I can tell that's not possible for wiki pages.

WDYT?

Edit: Apparently the contributing page _can_ be found, it's just called 'Getting started' in the side panel. I hadn't realized that earlier. :)
author_association: MEMBER
user: login: oppiabot[bot]
created_at: 2025-03-11T22:45:40Z
body: Hi @adhiamboperes, I'm going to mark this PR as stale because it hasn't had any updates for 7 days. If no further activity occurs within **7 days**, it will be automatically closed so that others can take up the issue.
If you are still working on this PR, please make a follow-up commit within **3 days** (and submit it for review, if applicable). Please also let us know if you are stuck so we can help you!

author_association: NONE
user: login: github-actions[bot]
created_at: 2025-03-14T03:20:06Z
body: # APK & AAB differences analysis
Note that this is a summarized snapshot. See the CI artifacts for detailed differences.

## Dev

<details><summary>Expand to see flavor specifics</summary>

### Universal APK
APK file size: 19 MiB (old), 19 MiB (new), **4 bytes** (Removed)

APK download size (estimated): 17 MiB (old), 17 MiB (new), **5 bytes** (Added)

Method count: 260423 (old), 260423 (new), **0** (No change)

Features: 2 (old), 2 (new), **0** (No change)

Permissions: 6 (old), 6 (new), **0** (No change)

Resources: 6832 (old), 6832 (new), **0** (No change)
- Anim: 43 (old), 43 (new), **0** (No change)
- Animator: 26 (old), 26 (new), **0** (No change)
- Array: 15 (old), 15 (new), **0** (No change)
- Attr: 922 (old), 922 (new), **0** (No change)
- Bool: 9 (old), 9 (new), **0** (No change)
- Color: 967 (old), 967 (new), **0** (No change)
- Dimen: 1048 (old), 1048 (new), **0** (No change)
- Drawable: 380 (old), 380 (new), **0** (No change)
- Id: 1285 (old), 1285 (new), **0** (No change)
- Integer: 37 (old), 37 (new), **0** (No change)
- Interpolator: 11 (old), 11 (new), **0** (No change)
- Layout: 380 (old), 380 (new), **0** (No change)
- Menu: 3 (old), 3 (new), **0** (No change)
- Mipmap: 1 (old), 1 (new), **0** (No change)
- Plurals: 10 (old), 10 (new), **0** (No change)
- Raw: 2 (old), 2 (new), **0** (No change)
- String: 855 (old), 855 (new), **0** (No change)
- Style: 832 (old), 832 (new), **0** (No change)
- Xml: 6 (old), 6 (new), **0** (No change)

Lesson assets: 111 (old), 111 (new), **0** (No change)

### AAB differences
<details><summary>Expand to see AAB specifics</summary>

Supported configurations:
- hdpi (same)
- ldpi (same)
- mdpi (same)
- tvdpi (same)
- xhdpi (same)
- xxhdpi (same)
- xxxhdpi (same)

#### Base APK
APK file size: 18 MiB (old), 18 MiB (new), **4 bytes** (Removed)
APK download size (estimated): 17 MiB (old), 17 MiB (new), **2 bytes** (Added)

#### Configuration hdpi
APK file size: 50 KiB (old), 50 KiB (new), **0 bytes** (No change)
APK download size (estimated): 18 KiB (old), 18 KiB (new), **0 bytes** (No change)

#### Configuration ldpi
APK file size: 49 KiB (old), 49 KiB (new), **0 bytes** (No change)
APK download size (estimated): 14 KiB (old), 14 KiB (new), **0 bytes** (No change)

#### Configuration mdpi
APK file size: 45 KiB (old), 45 KiB (new), **0 bytes** (No change)
APK download size (estimated): 14 KiB (old), 14 KiB (new), **0 bytes** (No change)

#### Configuration tvdpi
APK file size: 86 KiB (old), 86 KiB (new), **0 bytes** (No change)
APK download size (estimated): 29 KiB (old), 29 KiB (new), **0 bytes** (No change)

#### Configuration xhdpi
APK file size: 57 KiB (old), 57 KiB (new), **0 bytes** (No change)
APK download size (estimated): 21 KiB (old), 21 KiB (new), **0 bytes** (No change)

#### Configuration xxhdpi
APK file size: 63 KiB (old), 63 KiB (new), **0 bytes** (No change)
APK download size (estimated): 29 KiB (old), 29 KiB (new), **0 bytes** (No change)

#### Configuration xxxhdpi
APK file size: 63 KiB (old), 63 KiB (new), **0 bytes** (No change)
APK download size (estimated): 28 KiB (old), 28 KiB (new), **0 bytes** (No change)
</details></details>

## Alpha

<details><summary>Expand to see flavor specifics</summary>

### Universal APK
APK file size: 11 MiB (old), 11 MiB (new), **0 bytes** (No change)

APK download size (estimated): 10 MiB (old), 10 MiB (new), **13 bytes** (Removed)

Method count: 115867 (old), 115867 (new), **0** (No change)

Features: 2 (old), 2 (new), **0** (No change)

Permissions: 6 (old), 6 (new), **0** (No change)

Resources: 5800 (old), 5800 (new), **0** (No change)
- Anim: 33 (old), 33 (new), **0** (No change)
- Animator: 24 (old), 24 (new), **0** (No change)
- Array: 14 (old), 14 (new), **0** (No change)
- Attr: 888 (old), 888 (new), **0** (No change)
- Bool: 8 (old), 8 (new), **0** (No change)
- Color: 820 (old), 820 (new), **0** (No change)
- Dimen: 780 (old), 780 (new), **0** (No change)
- Drawable: 342 (old), 342 (new), **0** (No change)
- Id: 1231 (old), 1231 (new), **0** (No change)
- Integer: 32 (old), 32 (new), **0** (No change)
- Interpolator: 11 (old), 11 (new), **0** (No change)
- Layout: 343 (old), 343 (new), **0** (No change)
- Menu: 1 (old), 1 (new), **0** (No change)
- Mipmap: 1 (old), 1 (new), **0** (No change)
- Plurals: 10 (old), 10 (new), **0** (No change)
- String: 788 (old), 788 (new), **0** (No change)
- Style: 473 (old), 473 (new), **0** (No change)
- Xml: 1 (old), 1 (new), **0** (No change)

Lesson assets: 111 (old), 111 (new), **0** (No change)

### AAB differences
<details><summary>Expand to see AAB specifics</summary>

Supported configurations:
- hdpi (same)
- ldpi (same)
- mdpi (same)
- tvdpi (same)
- xhdpi (same)
- xxhdpi (same)
- xxxhdpi (same)

#### Base APK
APK file size: 11 MiB (old), 11 MiB (new), **0 bytes** (No change)
APK download size (estimated): 10 MiB (old), 10 MiB (new), **6 bytes** (Added)

#### Configuration hdpi
APK file size: 43 KiB (old), 43 KiB (new), **0 bytes** (No change)
APK download size (estimated): 17 KiB (old), 17 KiB (new), **0 bytes** (No change)

#### Configuration ldpi
APK file size: 44 KiB (old), 44 KiB (new), **0 bytes** (No change)
APK download size (estimated): 13 KiB (old), 13 KiB (new), **0 bytes** (No change)

#### Configuration mdpi
APK file size: 38 KiB (old), 38 KiB (new), **0 bytes** (No change)
APK download size (estimated): 13 KiB (old), 13 KiB (new), **0 bytes** (No change)

#### Configuration tvdpi
APK file size: 73 KiB (old), 73 KiB (new), **0 bytes** (No change)
APK download size (estimated): 27 KiB (old), 27 KiB (new), **0 bytes** (No change)

#### Configuration xhdpi
APK file size: 50 KiB (old), 50 KiB (new), **0 bytes** (No change)
APK download size (estimated): 20 KiB (old), 20 KiB (new), **0 bytes** (No change)

#### Configuration xxhdpi
APK file size: 55 KiB (old), 55 KiB (new), **0 bytes** (No change)
APK download size (estimated): 28 KiB (old), 28 KiB (new), **0 bytes** (No change)

#### Configuration xxxhdpi
APK file size: 55 KiB (old), 55 KiB (new), **0 bytes** (No change)
APK download size (estimated): 27 KiB (old), 27 KiB (new), **0 bytes** (No change)
</details></details>

## Beta

<details><summary>Expand to see flavor specifics</summary>

### Universal APK
APK file size: 11 MiB (old), 11 MiB (new), **12 bytes** (Removed)

APK download size (estimated): 10 MiB (old), 10 MiB (new), **36 bytes** (Removed)

Method count: 115873 (old), 115873 (new), **0** (No change)

Features: 2 (old), 2 (new), **0** (No change)

Permissions: 6 (old), 6 (new), **0** (No change)

Resources: 5800 (old), 5800 (new), **0** (No change)
- Anim: 33 (old), 33 (new), **0** (No change)
- Animator: 24 (old), 24 (new), **0** (No change)
- Array: 14 (old), 14 (new), **0** (No change)
- Attr: 888 (old), 888 (new), **0** (No change)
- Bool: 8 (old), 8 (new), **0** (No change)
- Color: 820 (old), 820 (new), **0** (No change)
- Dimen: 780 (old), 780 (new), **0** (No change)
- Drawable: 342 (old), 342 (new), **0** (No change)
- Id: 1231 (old), 1231 (new), **0** (No change)
- Integer: 32 (old), 32 (new), **0** (No change)
- Interpolator: 11 (old), 11 (new), **0** (No change)
- Layout: 343 (old), 343 (new), **0** (No change)
- Menu: 1 (old), 1 (new), **0** (No change)
- Mipmap: 1 (old), 1 (new), **0** (No change)
- Plurals: 10 (old), 10 (new), **0** (No change)
- String: 788 (old), 788 (new), **0** (No change)
- Style: 473 (old), 473 (new), **0** (No change)
- Xml: 1 (old), 1 (new), **0** (No change)

Lesson assets: 111 (old), 111 (new), **0** (No change)

### AAB differences
<details><summary>Expand to see AAB specifics</summary>

Supported configurations:
- hdpi (same)
- ldpi (same)
- mdpi (same)
- tvdpi (same)
- xhdpi (same)
- xxhdpi (same)
- xxxhdpi (same)

#### Base APK
APK file size: 10 MiB (old), 10 MiB (new), **8 bytes** (Removed)
APK download size (estimated): 9 MiB (old), 9 MiB (new), **25 bytes** (Removed)

#### Configuration hdpi
APK file size: 43 KiB (old), 43 KiB (new), **0 bytes** (No change)
APK download size (estimated): 17 KiB (old), 17 KiB (new), **0 bytes** (No change)

#### Configuration ldpi
APK file size: 44 KiB (old), 44 KiB (new), **0 bytes** (No change)
APK download size (estimated): 13 KiB (old), 13 KiB (new), **0 bytes** (No change)

#### Configuration mdpi
APK file size: 38 KiB (old), 38 KiB (new), **0 bytes** (No change)
APK download size (estimated): 13 KiB (old), 13 KiB (new), **0 bytes** (No change)

#### Configuration tvdpi
APK file size: 73 KiB (old), 73 KiB (new), **0 bytes** (No change)
APK download size (estimated): 27 KiB (old), 27 KiB (new), **0 bytes** (No change)

#### Configuration xhdpi
APK file size: 50 KiB (old), 50 KiB (new), **0 bytes** (No change)
APK download size (estimated): 20 KiB (old), 20 KiB (new), **0 bytes** (No change)

#### Configuration xxhdpi
APK file size: 55 KiB (old), 55 KiB (new), **0 bytes** (No change)
APK download size (estimated): 28 KiB (old), 28 KiB (new), **0 bytes** (No change)

#### Configuration xxxhdpi
APK file size: 55 KiB (old), 55 KiB (new), **0 bytes** (No change)
APK download size (estimated): 27 KiB (old), 27 KiB (new), **0 bytes** (No change)
</details></details>

## Ga

<details><summary>Expand to see flavor specifics</summary>

### Universal APK
APK file size: 11 MiB (old), 11 MiB (new), **8 bytes** (Removed)

APK download size (estimated): 10 MiB (old), 10 MiB (new), **30 bytes** (Removed)

Method count: 115873 (old), 115873 (new), **0** (No change)

Features: 2 (old), 2 (new), **0** (No change)

Permissions: 6 (old), 6 (new), **0** (No change)

Resources: 5800 (old), 5800 (new), **0** (No change)
- Anim: 33 (old), 33 (new), **0** (No change)
- Animator: 24 (old), 24 (new), **0** (No change)
- Array: 14 (old), 14 (new), **0** (No change)
- Attr: 888 (old), 888 (new), **0** (No change)
- Bool: 8 (old), 8 (new), **0** (No change)
- Color: 820 (old), 820 (new), **0** (No change)
- Dimen: 780 (old), 780 (new), **0** (No change)
- Drawable: 342 (old), 342 (new), **0** (No change)
- Id: 1231 (old), 1231 (new), **0** (No change)
- Integer: 32 (old), 32 (new), **0** (No change)
- Interpolator: 11 (old), 11 (new), **0** (No change)
- Layout: 343 (old), 343 (new), **0** (No change)
- Menu: 1 (old), 1 (new), **0** (No change)
- Mipmap: 1 (old), 1 (new), **0** (No change)
- Plurals: 10 (old), 10 (new), **0** (No change)
- String: 788 (old), 788 (new), **0** (No change)
- Style: 473 (old), 473 (new), **0** (No change)
- Xml: 1 (old), 1 (new), **0** (No change)

Lesson assets: 111 (old), 111 (new), **0** (No change)

### AAB differences
<details><summary>Expand to see AAB specifics</summary>

Supported configurations:
- hdpi (same)
- ldpi (same)
- mdpi (same)
- tvdpi (same)
- xhdpi (same)
- xxhdpi (same)
- xxxhdpi (same)

#### Base APK
APK file size: 10 MiB (old), 10 MiB (new), **8 bytes** (Removed)
APK download size (estimated): 9 MiB (old), 9 MiB (new), **44 bytes** (Removed)

#### Configuration hdpi
APK file size: 43 KiB (old), 43 KiB (new), **0 bytes** (No change)
APK download size (estimated): 17 KiB (old), 17 KiB (new), **0 bytes** (No change)

#### Configuration ldpi
APK file size: 44 KiB (old), 44 KiB (new), **0 bytes** (No change)
APK download size (estimated): 13 KiB (old), 13 KiB (new), **0 bytes** (No change)

#### Configuration mdpi
APK file size: 38 KiB (old), 38 KiB (new), **0 bytes** (No change)
APK download size (estimated): 13 KiB (old), 13 KiB (new), **0 bytes** (No change)

#### Configuration tvdpi
APK file size: 73 KiB (old), 73 KiB (new), **0 bytes** (No change)
APK download size (estimated): 27 KiB (old), 27 KiB (new), **0 bytes** (No change)

#### Configuration xhdpi
APK file size: 50 KiB (old), 50 KiB (new), **0 bytes** (No change)
APK download size (estimated): 20 KiB (old), 20 KiB (new), **0 bytes** (No change)

#### Configuration xxhdpi
APK file size: 55 KiB (old), 55 KiB (new), **0 bytes** (No change)
APK download size (estimated): 28 KiB (old), 28 KiB (new), **0 bytes** (No change)

#### Configuration xxxhdpi
APK file size: 55 KiB (old), 55 KiB (new), **0 bytes** (No change)
APK download size (estimated): 27 KiB (old), 27 KiB (new), **0 bytes** (No change)
</details></details>
author_association: NONE
user: login: adhiamboperes
created_at: 2025-03-14T11:38:14Z
body: PTAL @BenHenning. Could you also please clarify https://github.com/oppia/oppia-android/pull/5723#discussion_r1994476963?

Also, something happened when I was renaming the "Glossary" page, did not use `git mv `and instead it appears to be deleted and "User Guide" is a replacement.
author_association: CONTRIBUTOR
user: login: github-actions[bot]
created_at: 2025-03-16T02:58:08Z
body: # APK & AAB differences analysis
Note that this is a summarized snapshot. See the CI artifacts for detailed differences.

## Dev

<details><summary>Expand to see flavor specifics</summary>

### Universal APK
APK file size: 19 MiB (old), 19 MiB (new), **4 bytes** (Removed)

APK download size (estimated): 17 MiB (old), 17 MiB (new), **24 bytes** (Removed)

Method count: 260423 (old), 260423 (new), **0** (No change)

Features: 2 (old), 2 (new), **0** (No change)

Permissions: 6 (old), 6 (new), **0** (No change)

Resources: 6832 (old), 6832 (new), **0** (No change)
- Anim: 43 (old), 43 (new), **0** (No change)
- Animator: 26 (old), 26 (new), **0** (No change)
- Array: 15 (old), 15 (new), **0** (No change)
- Attr: 922 (old), 922 (new), **0** (No change)
- Bool: 9 (old), 9 (new), **0** (No change)
- Color: 967 (old), 967 (new), **0** (No change)
- Dimen: 1048 (old), 1048 (new), **0** (No change)
- Drawable: 380 (old), 380 (new), **0** (No change)
- Id: 1285 (old), 1285 (new), **0** (No change)
- Integer: 37 (old), 37 (new), **0** (No change)
- Interpolator: 11 (old), 11 (new), **0** (No change)
- Layout: 380 (old), 380 (new), **0** (No change)
- Menu: 3 (old), 3 (new), **0** (No change)
- Mipmap: 1 (old), 1 (new), **0** (No change)
- Plurals: 10 (old), 10 (new), **0** (No change)
- Raw: 2 (old), 2 (new), **0** (No change)
- String: 855 (old), 855 (new), **0** (No change)
- Style: 832 (old), 832 (new), **0** (No change)
- Xml: 6 (old), 6 (new), **0** (No change)

Lesson assets: 111 (old), 111 (new), **0** (No change)

### AAB differences
<details><summary>Expand to see AAB specifics</summary>

Supported configurations:
- hdpi (same)
- ldpi (same)
- mdpi (same)
- tvdpi (same)
- xhdpi (same)
- xxhdpi (same)
- xxxhdpi (same)

#### Base APK
APK file size: 18 MiB (old), 18 MiB (new), **4 bytes** (Removed)
APK download size (estimated): 17 MiB (old), 17 MiB (new), **32 bytes** (Removed)

#### Configuration hdpi
APK file size: 50 KiB (old), 50 KiB (new), **0 bytes** (No change)
APK download size (estimated): 18 KiB (old), 18 KiB (new), **0 bytes** (No change)

#### Configuration ldpi
APK file size: 49 KiB (old), 49 KiB (new), **0 bytes** (No change)
APK download size (estimated): 14 KiB (old), 14 KiB (new), **0 bytes** (No change)

#### Configuration mdpi
APK file size: 45 KiB (old), 45 KiB (new), **0 bytes** (No change)
APK download size (estimated): 14 KiB (old), 14 KiB (new), **0 bytes** (No change)

#### Configuration tvdpi
APK file size: 86 KiB (old), 86 KiB (new), **0 bytes** (No change)
APK download size (estimated): 29 KiB (old), 29 KiB (new), **0 bytes** (No change)

#### Configuration xhdpi
APK file size: 57 KiB (old), 57 KiB (new), **0 bytes** (No change)
APK download size (estimated): 21 KiB (old), 21 KiB (new), **0 bytes** (No change)

#### Configuration xxhdpi
APK file size: 63 KiB (old), 63 KiB (new), **0 bytes** (No change)
APK download size (estimated): 29 KiB (old), 29 KiB (new), **0 bytes** (No change)

#### Configuration xxxhdpi
APK file size: 63 KiB (old), 63 KiB (new), **0 bytes** (No change)
APK download size (estimated): 28 KiB (old), 28 KiB (new), **0 bytes** (No change)
</details></details>

## Alpha

<details><summary>Expand to see flavor specifics</summary>

### Universal APK
APK file size: 11 MiB (old), 11 MiB (new), **0 bytes** (No change)

APK download size (estimated): 10 MiB (old), 10 MiB (new), **12 bytes** (Removed)

Method count: 115867 (old), 115867 (new), **0** (No change)

Features: 2 (old), 2 (new), **0** (No change)

Permissions: 6 (old), 6 (new), **0** (No change)

Resources: 5800 (old), 5800 (new), **0** (No change)
- Anim: 33 (old), 33 (new), **0** (No change)
- Animator: 24 (old), 24 (new), **0** (No change)
- Array: 14 (old), 14 (new), **0** (No change)
- Attr: 888 (old), 888 (new), **0** (No change)
- Bool: 8 (old), 8 (new), **0** (No change)
- Color: 820 (old), 820 (new), **0** (No change)
- Dimen: 780 (old), 780 (new), **0** (No change)
- Drawable: 342 (old), 342 (new), **0** (No change)
- Id: 1231 (old), 1231 (new), **0** (No change)
- Integer: 32 (old), 32 (new), **0** (No change)
- Interpolator: 11 (old), 11 (new), **0** (No change)
- Layout: 343 (old), 343 (new), **0** (No change)
- Menu: 1 (old), 1 (new), **0** (No change)
- Mipmap: 1 (old), 1 (new), **0** (No change)
- Plurals: 10 (old), 10 (new), **0** (No change)
- String: 788 (old), 788 (new), **0** (No change)
- Style: 473 (old), 473 (new), **0** (No change)
- Xml: 1 (old), 1 (new), **0** (No change)

Lesson assets: 111 (old), 111 (new), **0** (No change)

### AAB differences
<details><summary>Expand to see AAB specifics</summary>

Supported configurations:
- hdpi (same)
- ldpi (same)
- mdpi (same)
- tvdpi (same)
- xhdpi (same)
- xxhdpi (same)
- xxxhdpi (same)

#### Base APK
APK file size: 11 MiB (old), 11 MiB (new), **0 bytes** (No change)
APK download size (estimated): 10 MiB (old), 10 MiB (new), **31 bytes** (Added)

#### Configuration hdpi
APK file size: 43 KiB (old), 43 KiB (new), **0 bytes** (No change)
APK download size (estimated): 17 KiB (old), 17 KiB (new), **0 bytes** (No change)

#### Configuration ldpi
APK file size: 44 KiB (old), 44 KiB (new), **0 bytes** (No change)
APK download size (estimated): 13 KiB (old), 13 KiB (new), **0 bytes** (No change)

#### Configuration mdpi
APK file size: 38 KiB (old), 38 KiB (new), **0 bytes** (No change)
APK download size (estimated): 13 KiB (old), 13 KiB (new), **0 bytes** (No change)

#### Configuration tvdpi
APK file size: 73 KiB (old), 73 KiB (new), **0 bytes** (No change)
APK download size (estimated): 27 KiB (old), 27 KiB (new), **0 bytes** (No change)

#### Configuration xhdpi
APK file size: 50 KiB (old), 50 KiB (new), **0 bytes** (No change)
APK download size (estimated): 20 KiB (old), 20 KiB (new), **0 bytes** (No change)

#### Configuration xxhdpi
APK file size: 55 KiB (old), 55 KiB (new), **0 bytes** (No change)
APK download size (estimated): 28 KiB (old), 28 KiB (new), **0 bytes** (No change)

#### Configuration xxxhdpi
APK file size: 55 KiB (old), 55 KiB (new), **0 bytes** (No change)
APK download size (estimated): 27 KiB (old), 27 KiB (new), **0 bytes** (No change)
</details></details>

## Beta

<details><summary>Expand to see flavor specifics</summary>

### Universal APK
APK file size: 11 MiB (old), 11 MiB (new), **4 bytes** (Removed)

APK download size (estimated): 10 MiB (old), 10 MiB (new), **70 bytes** (Removed)

Method count: 115873 (old), 115873 (new), **0** (No change)

Features: 2 (old), 2 (new), **0** (No change)

Permissions: 6 (old), 6 (new), **0** (No change)

Resources: 5800 (old), 5800 (new), **0** (No change)
- Anim: 33 (old), 33 (new), **0** (No change)
- Animator: 24 (old), 24 (new), **0** (No change)
- Array: 14 (old), 14 (new), **0** (No change)
- Attr: 888 (old), 888 (new), **0** (No change)
- Bool: 8 (old), 8 (new), **0** (No change)
- Color: 820 (old), 820 (new), **0** (No change)
- Dimen: 780 (old), 780 (new), **0** (No change)
- Drawable: 342 (old), 342 (new), **0** (No change)
- Id: 1231 (old), 1231 (new), **0** (No change)
- Integer: 32 (old), 32 (new), **0** (No change)
- Interpolator: 11 (old), 11 (new), **0** (No change)
- Layout: 343 (old), 343 (new), **0** (No change)
- Menu: 1 (old), 1 (new), **0** (No change)
- Mipmap: 1 (old), 1 (new), **0** (No change)
- Plurals: 10 (old), 10 (new), **0** (No change)
- String: 788 (old), 788 (new), **0** (No change)
- Style: 473 (old), 473 (new), **0** (No change)
- Xml: 1 (old), 1 (new), **0** (No change)

Lesson assets: 111 (old), 111 (new), **0** (No change)

### AAB differences
<details><summary>Expand to see AAB specifics</summary>

Supported configurations:
- hdpi (same)
- ldpi (same)
- mdpi (same)
- tvdpi (same)
- xhdpi (same)
- xxhdpi (same)
- xxxhdpi (same)

#### Base APK
APK file size: 10 MiB (old), 10 MiB (new), **4 bytes** (Removed)
APK download size (estimated): 9 MiB (old), 9 MiB (new), **7 bytes** (Removed)

#### Configuration hdpi
APK file size: 43 KiB (old), 43 KiB (new), **0 bytes** (No change)
APK download size (estimated): 17 KiB (old), 17 KiB (new), **0 bytes** (No change)

#### Configuration ldpi
APK file size: 44 KiB (old), 44 KiB (new), **0 bytes** (No change)
APK download size (estimated): 13 KiB (old), 13 KiB (new), **0 bytes** (No change)

#### Configuration mdpi
APK file size: 38 KiB (old), 38 KiB (new), **0 bytes** (No change)
APK download size (estimated): 13 KiB (old), 13 KiB (new), **0 bytes** (No change)

#### Configuration tvdpi
APK file size: 73 KiB (old), 73 KiB (new), **0 bytes** (No change)
APK download size (estimated): 27 KiB (old), 27 KiB (new), **0 bytes** (No change)

#### Configuration xhdpi
APK file size: 50 KiB (old), 50 KiB (new), **0 bytes** (No change)
APK download size (estimated): 20 KiB (old), 20 KiB (new), **0 bytes** (No change)

#### Configuration xxhdpi
APK file size: 55 KiB (old), 55 KiB (new), **0 bytes** (No change)
APK download size (estimated): 28 KiB (old), 28 KiB (new), **0 bytes** (No change)

#### Configuration xxxhdpi
APK file size: 55 KiB (old), 55 KiB (new), **0 bytes** (No change)
APK download size (estimated): 27 KiB (old), 27 KiB (new), **0 bytes** (No change)
</details></details>

## Ga

<details><summary>Expand to see flavor specifics</summary>

### Universal APK
APK file size: 11 MiB (old), 11 MiB (new), **4 bytes** (Removed)

APK download size (estimated): 10 MiB (old), 10 MiB (new), **25 bytes** (Removed)

Method count: 115873 (old), 115873 (new), **0** (No change)

Features: 2 (old), 2 (new), **0** (No change)

Permissions: 6 (old), 6 (new), **0** (No change)

Resources: 5800 (old), 5800 (new), **0** (No change)
- Anim: 33 (old), 33 (new), **0** (No change)
- Animator: 24 (old), 24 (new), **0** (No change)
- Array: 14 (old), 14 (new), **0** (No change)
- Attr: 888 (old), 888 (new), **0** (No change)
- Bool: 8 (old), 8 (new), **0** (No change)
- Color: 820 (old), 820 (new), **0** (No change)
- Dimen: 780 (old), 780 (new), **0** (No change)
- Drawable: 342 (old), 342 (new), **0** (No change)
- Id: 1231 (old), 1231 (new), **0** (No change)
- Integer: 32 (old), 32 (new), **0** (No change)
- Interpolator: 11 (old), 11 (new), **0** (No change)
- Layout: 343 (old), 343 (new), **0** (No change)
- Menu: 1 (old), 1 (new), **0** (No change)
- Mipmap: 1 (old), 1 (new), **0** (No change)
- Plurals: 10 (old), 10 (new), **0** (No change)
- String: 788 (old), 788 (new), **0** (No change)
- Style: 473 (old), 473 (new), **0** (No change)
- Xml: 1 (old), 1 (new), **0** (No change)

Lesson assets: 111 (old), 111 (new), **0** (No change)

### AAB differences
<details><summary>Expand to see AAB specifics</summary>

Supported configurations:
- hdpi (same)
- ldpi (same)
- mdpi (same)
- tvdpi (same)
- xhdpi (same)
- xxhdpi (same)
- xxxhdpi (same)

#### Base APK
APK file size: 10 MiB (old), 10 MiB (new), **4 bytes** (Removed)
APK download size (estimated): 9 MiB (old), 9 MiB (new), **37 bytes** (Removed)

#### Configuration hdpi
APK file size: 43 KiB (old), 43 KiB (new), **0 bytes** (No change)
APK download size (estimated): 17 KiB (old), 17 KiB (new), **0 bytes** (No change)

#### Configuration ldpi
APK file size: 44 KiB (old), 44 KiB (new), **0 bytes** (No change)
APK download size (estimated): 13 KiB (old), 13 KiB (new), **0 bytes** (No change)

#### Configuration mdpi
APK file size: 38 KiB (old), 38 KiB (new), **0 bytes** (No change)
APK download size (estimated): 13 KiB (old), 13 KiB (new), **0 bytes** (No change)

#### Configuration tvdpi
APK file size: 73 KiB (old), 73 KiB (new), **0 bytes** (No change)
APK download size (estimated): 27 KiB (old), 27 KiB (new), **0 bytes** (No change)

#### Configuration xhdpi
APK file size: 50 KiB (old), 50 KiB (new), **0 bytes** (No change)
APK download size (estimated): 20 KiB (old), 20 KiB (new), **0 bytes** (No change)

#### Configuration xxhdpi
APK file size: 55 KiB (old), 55 KiB (new), **0 bytes** (No change)
APK download size (estimated): 28 KiB (old), 28 KiB (new), **0 bytes** (No change)

#### Configuration xxxhdpi
APK file size: 55 KiB (old), 55 KiB (new), **0 bytes** (No change)
APK download size (estimated): 27 KiB (old), 27 KiB (new), **0 bytes** (No change)
</details></details>
author_association: NONE
user: login: adhiamboperes
created_at: 2025-03-18T20:25:01Z
body: Thanks for the follow up @manas-yu! I have made the changes. 
author_association: CONTRIBUTOR
user: login: github-actions[bot]
created_at: 2025-03-19T04:20:47Z
body: # APK & AAB differences analysis
Note that this is a summarized snapshot. See the CI artifacts for detailed differences.

## Dev

<details><summary>Expand to see flavor specifics</summary>

### Universal APK
APK file size: 19 MiB (old), 19 MiB (new), **0 bytes** (No change)

APK download size (estimated): 17 MiB (old), 17 MiB (new), **16 bytes** (Added)

Method count: 260423 (old), 260423 (new), **0** (No change)

Features: 2 (old), 2 (new), **0** (No change)

Permissions: 6 (old), 6 (new), **0** (No change)

Resources: 6832 (old), 6832 (new), **0** (No change)
- Anim: 43 (old), 43 (new), **0** (No change)
- Animator: 26 (old), 26 (new), **0** (No change)
- Array: 15 (old), 15 (new), **0** (No change)
- Attr: 922 (old), 922 (new), **0** (No change)
- Bool: 9 (old), 9 (new), **0** (No change)
- Color: 967 (old), 967 (new), **0** (No change)
- Dimen: 1048 (old), 1048 (new), **0** (No change)
- Drawable: 380 (old), 380 (new), **0** (No change)
- Id: 1285 (old), 1285 (new), **0** (No change)
- Integer: 37 (old), 37 (new), **0** (No change)
- Interpolator: 11 (old), 11 (new), **0** (No change)
- Layout: 380 (old), 380 (new), **0** (No change)
- Menu: 3 (old), 3 (new), **0** (No change)
- Mipmap: 1 (old), 1 (new), **0** (No change)
- Plurals: 10 (old), 10 (new), **0** (No change)
- Raw: 2 (old), 2 (new), **0** (No change)
- String: 855 (old), 855 (new), **0** (No change)
- Style: 832 (old), 832 (new), **0** (No change)
- Xml: 6 (old), 6 (new), **0** (No change)

Lesson assets: 111 (old), 111 (new), **0** (No change)

### AAB differences
<details><summary>Expand to see AAB specifics</summary>

Supported configurations:
- hdpi (same)
- ldpi (same)
- mdpi (same)
- tvdpi (same)
- xhdpi (same)
- xxhdpi (same)
- xxxhdpi (same)

#### Base APK
APK file size: 18 MiB (old), 18 MiB (new), **4 bytes** (Added)
APK download size (estimated): 17 MiB (old), 17 MiB (new), **3 bytes** (Removed)

#### Configuration hdpi
APK file size: 50 KiB (old), 50 KiB (new), **0 bytes** (No change)
APK download size (estimated): 18 KiB (old), 18 KiB (new), **0 bytes** (No change)

#### Configuration ldpi
APK file size: 49 KiB (old), 49 KiB (new), **0 bytes** (No change)
APK download size (estimated): 14 KiB (old), 14 KiB (new), **0 bytes** (No change)

#### Configuration mdpi
APK file size: 45 KiB (old), 45 KiB (new), **0 bytes** (No change)
APK download size (estimated): 14 KiB (old), 14 KiB (new), **0 bytes** (No change)

#### Configuration tvdpi
APK file size: 86 KiB (old), 86 KiB (new), **0 bytes** (No change)
APK download size (estimated): 29 KiB (old), 29 KiB (new), **0 bytes** (No change)

#### Configuration xhdpi
APK file size: 57 KiB (old), 57 KiB (new), **0 bytes** (No change)
APK download size (estimated): 21 KiB (old), 21 KiB (new), **0 bytes** (No change)

#### Configuration xxhdpi
APK file size: 63 KiB (old), 63 KiB (new), **0 bytes** (No change)
APK download size (estimated): 29 KiB (old), 29 KiB (new), **0 bytes** (No change)

#### Configuration xxxhdpi
APK file size: 63 KiB (old), 63 KiB (new), **0 bytes** (No change)
APK download size (estimated): 28 KiB (old), 28 KiB (new), **0 bytes** (No change)
</details></details>

## Alpha

<details><summary>Expand to see flavor specifics</summary>

### Universal APK
APK file size: 11 MiB (old), 11 MiB (new), **0 bytes** (No change)

APK download size (estimated): 10 MiB (old), 10 MiB (new), **0 bytes** (No change)

Method count: 115867 (old), 115867 (new), **0** (No change)

Features: 2 (old), 2 (new), **0** (No change)

Permissions: 6 (old), 6 (new), **0** (No change)

Resources: 5800 (old), 5800 (new), **0** (No change)
- Anim: 33 (old), 33 (new), **0** (No change)
- Animator: 24 (old), 24 (new), **0** (No change)
- Array: 14 (old), 14 (new), **0** (No change)
- Attr: 888 (old), 888 (new), **0** (No change)
- Bool: 8 (old), 8 (new), **0** (No change)
- Color: 820 (old), 820 (new), **0** (No change)
- Dimen: 780 (old), 780 (new), **0** (No change)
- Drawable: 342 (old), 342 (new), **0** (No change)
- Id: 1231 (old), 1231 (new), **0** (No change)
- Integer: 32 (old), 32 (new), **0** (No change)
- Interpolator: 11 (old), 11 (new), **0** (No change)
- Layout: 343 (old), 343 (new), **0** (No change)
- Menu: 1 (old), 1 (new), **0** (No change)
- Mipmap: 1 (old), 1 (new), **0** (No change)
- Plurals: 10 (old), 10 (new), **0** (No change)
- String: 788 (old), 788 (new), **0** (No change)
- Style: 473 (old), 473 (new), **0** (No change)
- Xml: 1 (old), 1 (new), **0** (No change)

Lesson assets: 111 (old), 111 (new), **0** (No change)

### AAB differences
<details><summary>Expand to see AAB specifics</summary>

Supported configurations:
- hdpi (same)
- ldpi (same)
- mdpi (same)
- tvdpi (same)
- xhdpi (same)
- xxhdpi (same)
- xxxhdpi (same)

#### Base APK
APK file size: 11 MiB (old), 11 MiB (new), **0 bytes** (No change)
APK download size (estimated): 10 MiB (old), 10 MiB (new), **4 bytes** (Removed)

#### Configuration hdpi
APK file size: 43 KiB (old), 43 KiB (new), **0 bytes** (No change)
APK download size (estimated): 17 KiB (old), 17 KiB (new), **0 bytes** (No change)

#### Configuration ldpi
APK file size: 44 KiB (old), 44 KiB (new), **0 bytes** (No change)
APK download size (estimated): 13 KiB (old), 13 KiB (new), **0 bytes** (No change)

#### Configuration mdpi
APK file size: 38 KiB (old), 38 KiB (new), **0 bytes** (No change)
APK download size (estimated): 13 KiB (old), 13 KiB (new), **0 bytes** (No change)

#### Configuration tvdpi
APK file size: 73 KiB (old), 73 KiB (new), **0 bytes** (No change)
APK download size (estimated): 27 KiB (old), 27 KiB (new), **0 bytes** (No change)

#### Configuration xhdpi
APK file size: 50 KiB (old), 50 KiB (new), **0 bytes** (No change)
APK download size (estimated): 20 KiB (old), 20 KiB (new), **0 bytes** (No change)

#### Configuration xxhdpi
APK file size: 55 KiB (old), 55 KiB (new), **0 bytes** (No change)
APK download size (estimated): 28 KiB (old), 28 KiB (new), **0 bytes** (No change)

#### Configuration xxxhdpi
APK file size: 55 KiB (old), 55 KiB (new), **0 bytes** (No change)
APK download size (estimated): 27 KiB (old), 27 KiB (new), **0 bytes** (No change)
</details></details>

## Beta

<details><summary>Expand to see flavor specifics</summary>

### Universal APK
APK file size: 11 MiB (old), 11 MiB (new), **8 bytes** (Removed)

APK download size (estimated): 10 MiB (old), 10 MiB (new), **67 bytes** (Removed)

Method count: 115873 (old), 115873 (new), **0** (No change)

Features: 2 (old), 2 (new), **0** (No change)

Permissions: 6 (old), 6 (new), **0** (No change)

Resources: 5800 (old), 5800 (new), **0** (No change)
- Anim: 33 (old), 33 (new), **0** (No change)
- Animator: 24 (old), 24 (new), **0** (No change)
- Array: 14 (old), 14 (new), **0** (No change)
- Attr: 888 (old), 888 (new), **0** (No change)
- Bool: 8 (old), 8 (new), **0** (No change)
- Color: 820 (old), 820 (new), **0** (No change)
- Dimen: 780 (old), 780 (new), **0** (No change)
- Drawable: 342 (old), 342 (new), **0** (No change)
- Id: 1231 (old), 1231 (new), **0** (No change)
- Integer: 32 (old), 32 (new), **0** (No change)
- Interpolator: 11 (old), 11 (new), **0** (No change)
- Layout: 343 (old), 343 (new), **0** (No change)
- Menu: 1 (old), 1 (new), **0** (No change)
- Mipmap: 1 (old), 1 (new), **0** (No change)
- Plurals: 10 (old), 10 (new), **0** (No change)
- String: 788 (old), 788 (new), **0** (No change)
- Style: 473 (old), 473 (new), **0** (No change)
- Xml: 1 (old), 1 (new), **0** (No change)

Lesson assets: 111 (old), 111 (new), **0** (No change)

### AAB differences
<details><summary>Expand to see AAB specifics</summary>

Supported configurations:
- hdpi (same)
- ldpi (same)
- mdpi (same)
- tvdpi (same)
- xhdpi (same)
- xxhdpi (same)
- xxxhdpi (same)

#### Base APK
APK file size: 10 MiB (old), 10 MiB (new), **8 bytes** (Removed)
APK download size (estimated): 9 MiB (old), 9 MiB (new), **42 bytes** (Removed)

#### Configuration hdpi
APK file size: 43 KiB (old), 43 KiB (new), **0 bytes** (No change)
APK download size (estimated): 17 KiB (old), 17 KiB (new), **0 bytes** (No change)

#### Configuration ldpi
APK file size: 44 KiB (old), 44 KiB (new), **0 bytes** (No change)
APK download size (estimated): 13 KiB (old), 13 KiB (new), **0 bytes** (No change)

#### Configuration mdpi
APK file size: 38 KiB (old), 38 KiB (new), **0 bytes** (No change)
APK download size (estimated): 13 KiB (old), 13 KiB (new), **0 bytes** (No change)

#### Configuration tvdpi
APK file size: 73 KiB (old), 73 KiB (new), **0 bytes** (No change)
APK download size (estimated): 27 KiB (old), 27 KiB (new), **0 bytes** (No change)

#### Configuration xhdpi
APK file size: 50 KiB (old), 50 KiB (new), **0 bytes** (No change)
APK download size (estimated): 20 KiB (old), 20 KiB (new), **0 bytes** (No change)

#### Configuration xxhdpi
APK file size: 55 KiB (old), 55 KiB (new), **0 bytes** (No change)
APK download size (estimated): 28 KiB (old), 28 KiB (new), **0 bytes** (No change)

#### Configuration xxxhdpi
APK file size: 55 KiB (old), 55 KiB (new), **0 bytes** (No change)
APK download size (estimated): 27 KiB (old), 27 KiB (new), **0 bytes** (No change)
</details></details>

## Ga

<details><summary>Expand to see flavor specifics</summary>

### Universal APK
APK file size: 11 MiB (old), 11 MiB (new), **0 bytes** (No change)

APK download size (estimated): 10 MiB (old), 10 MiB (new), **12 bytes** (Removed)

Method count: 115873 (old), 115873 (new), **0** (No change)

Features: 2 (old), 2 (new), **0** (No change)

Permissions: 6 (old), 6 (new), **0** (No change)

Resources: 5800 (old), 5800 (new), **0** (No change)
- Anim: 33 (old), 33 (new), **0** (No change)
- Animator: 24 (old), 24 (new), **0** (No change)
- Array: 14 (old), 14 (new), **0** (No change)
- Attr: 888 (old), 888 (new), **0** (No change)
- Bool: 8 (old), 8 (new), **0** (No change)
- Color: 820 (old), 820 (new), **0** (No change)
- Dimen: 780 (old), 780 (new), **0** (No change)
- Drawable: 342 (old), 342 (new), **0** (No change)
- Id: 1231 (old), 1231 (new), **0** (No change)
- Integer: 32 (old), 32 (new), **0** (No change)
- Interpolator: 11 (old), 11 (new), **0** (No change)
- Layout: 343 (old), 343 (new), **0** (No change)
- Menu: 1 (old), 1 (new), **0** (No change)
- Mipmap: 1 (old), 1 (new), **0** (No change)
- Plurals: 10 (old), 10 (new), **0** (No change)
- String: 788 (old), 788 (new), **0** (No change)
- Style: 473 (old), 473 (new), **0** (No change)
- Xml: 1 (old), 1 (new), **0** (No change)

Lesson assets: 111 (old), 111 (new), **0** (No change)

### AAB differences
<details><summary>Expand to see AAB specifics</summary>

Supported configurations:
- hdpi (same)
- ldpi (same)
- mdpi (same)
- tvdpi (same)
- xhdpi (same)
- xxhdpi (same)
- xxxhdpi (same)

#### Base APK
APK file size: 10 MiB (old), 10 MiB (new), **0 bytes** (No change)
APK download size (estimated): 9 MiB (old), 9 MiB (new), **6 bytes** (Added)

#### Configuration hdpi
APK file size: 43 KiB (old), 43 KiB (new), **0 bytes** (No change)
APK download size (estimated): 17 KiB (old), 17 KiB (new), **0 bytes** (No change)

#### Configuration ldpi
APK file size: 44 KiB (old), 44 KiB (new), **0 bytes** (No change)
APK download size (estimated): 13 KiB (old), 13 KiB (new), **0 bytes** (No change)

#### Configuration mdpi
APK file size: 38 KiB (old), 38 KiB (new), **0 bytes** (No change)
APK download size (estimated): 13 KiB (old), 13 KiB (new), **0 bytes** (No change)

#### Configuration tvdpi
APK file size: 73 KiB (old), 73 KiB (new), **0 bytes** (No change)
APK download size (estimated): 27 KiB (old), 27 KiB (new), **0 bytes** (No change)

#### Configuration xhdpi
APK file size: 50 KiB (old), 50 KiB (new), **0 bytes** (No change)
APK download size (estimated): 20 KiB (old), 20 KiB (new), **0 bytes** (No change)

#### Configuration xxhdpi
APK file size: 55 KiB (old), 55 KiB (new), **0 bytes** (No change)
APK download size (estimated): 28 KiB (old), 28 KiB (new), **0 bytes** (No change)

#### Configuration xxxhdpi
APK file size: 55 KiB (old), 55 KiB (new), **0 bytes** (No change)
APK download size (estimated): 27 KiB (old), 27 KiB (new), **0 bytes** (No change)
</details></details>
author_association: NONE
user: login: adhiamboperes
created_at: 2025-03-19T16:13:28Z
body: @BenHenning, PTAL. 
author_association: CONTRIBUTOR
user: login: github-actions[bot]
created_at: 2025-03-20T03:47:23Z
body: # APK & AAB differences analysis
Note that this is a summarized snapshot. See the CI artifacts for detailed differences.

## Dev

<details><summary>Expand to see flavor specifics</summary>

### Universal APK
APK file size: 19 MiB (old), 19 MiB (new), **8 bytes** (Removed)

APK download size (estimated): 17 MiB (old), 17 MiB (new), **9 bytes** (Added)

Method count: 260423 (old), 260423 (new), **0** (No change)

Features: 2 (old), 2 (new), **0** (No change)

Permissions: 6 (old), 6 (new), **0** (No change)

Resources: 6832 (old), 6832 (new), **0** (No change)
- Anim: 43 (old), 43 (new), **0** (No change)
- Animator: 26 (old), 26 (new), **0** (No change)
- Array: 15 (old), 15 (new), **0** (No change)
- Attr: 922 (old), 922 (new), **0** (No change)
- Bool: 9 (old), 9 (new), **0** (No change)
- Color: 967 (old), 967 (new), **0** (No change)
- Dimen: 1048 (old), 1048 (new), **0** (No change)
- Drawable: 380 (old), 380 (new), **0** (No change)
- Id: 1285 (old), 1285 (new), **0** (No change)
- Integer: 37 (old), 37 (new), **0** (No change)
- Interpolator: 11 (old), 11 (new), **0** (No change)
- Layout: 380 (old), 380 (new), **0** (No change)
- Menu: 3 (old), 3 (new), **0** (No change)
- Mipmap: 1 (old), 1 (new), **0** (No change)
- Plurals: 10 (old), 10 (new), **0** (No change)
- Raw: 2 (old), 2 (new), **0** (No change)
- String: 855 (old), 855 (new), **0** (No change)
- Style: 832 (old), 832 (new), **0** (No change)
- Xml: 6 (old), 6 (new), **0** (No change)

Lesson assets: 111 (old), 111 (new), **0** (No change)

### AAB differences
<details><summary>Expand to see AAB specifics</summary>

Supported configurations:
- hdpi (same)
- ldpi (same)
- mdpi (same)
- tvdpi (same)
- xhdpi (same)
- xxhdpi (same)
- xxxhdpi (same)

#### Base APK
APK file size: 18 MiB (old), 18 MiB (new), **8 bytes** (Removed)
APK download size (estimated): 17 MiB (old), 17 MiB (new), **12 bytes** (Added)

#### Configuration hdpi
APK file size: 50 KiB (old), 50 KiB (new), **0 bytes** (No change)
APK download size (estimated): 18 KiB (old), 18 KiB (new), **0 bytes** (No change)

#### Configuration ldpi
APK file size: 49 KiB (old), 49 KiB (new), **0 bytes** (No change)
APK download size (estimated): 14 KiB (old), 14 KiB (new), **0 bytes** (No change)

#### Configuration mdpi
APK file size: 45 KiB (old), 45 KiB (new), **0 bytes** (No change)
APK download size (estimated): 14 KiB (old), 14 KiB (new), **0 bytes** (No change)

#### Configuration tvdpi
APK file size: 86 KiB (old), 86 KiB (new), **0 bytes** (No change)
APK download size (estimated): 29 KiB (old), 29 KiB (new), **0 bytes** (No change)

#### Configuration xhdpi
APK file size: 57 KiB (old), 57 KiB (new), **0 bytes** (No change)
APK download size (estimated): 21 KiB (old), 21 KiB (new), **0 bytes** (No change)

#### Configuration xxhdpi
APK file size: 63 KiB (old), 63 KiB (new), **0 bytes** (No change)
APK download size (estimated): 29 KiB (old), 29 KiB (new), **0 bytes** (No change)

#### Configuration xxxhdpi
APK file size: 63 KiB (old), 63 KiB (new), **0 bytes** (No change)
APK download size (estimated): 28 KiB (old), 28 KiB (new), **0 bytes** (No change)
</details></details>

## Alpha

<details><summary>Expand to see flavor specifics</summary>

### Universal APK
APK file size: 11 MiB (old), 11 MiB (new), **0 bytes** (No change)

APK download size (estimated): 10 MiB (old), 10 MiB (new), **15 bytes** (Removed)

Method count: 115867 (old), 115867 (new), **0** (No change)

Features: 2 (old), 2 (new), **0** (No change)

Permissions: 6 (old), 6 (new), **0** (No change)

Resources: 5800 (old), 5800 (new), **0** (No change)
- Anim: 33 (old), 33 (new), **0** (No change)
- Animator: 24 (old), 24 (new), **0** (No change)
- Array: 14 (old), 14 (new), **0** (No change)
- Attr: 888 (old), 888 (new), **0** (No change)
- Bool: 8 (old), 8 (new), **0** (No change)
- Color: 820 (old), 820 (new), **0** (No change)
- Dimen: 780 (old), 780 (new), **0** (No change)
- Drawable: 342 (old), 342 (new), **0** (No change)
- Id: 1231 (old), 1231 (new), **0** (No change)
- Integer: 32 (old), 32 (new), **0** (No change)
- Interpolator: 11 (old), 11 (new), **0** (No change)
- Layout: 343 (old), 343 (new), **0** (No change)
- Menu: 1 (old), 1 (new), **0** (No change)
- Mipmap: 1 (old), 1 (new), **0** (No change)
- Plurals: 10 (old), 10 (new), **0** (No change)
- String: 788 (old), 788 (new), **0** (No change)
- Style: 473 (old), 473 (new), **0** (No change)
- Xml: 1 (old), 1 (new), **0** (No change)

Lesson assets: 111 (old), 111 (new), **0** (No change)

### AAB differences
<details><summary>Expand to see AAB specifics</summary>

Supported configurations:
- hdpi (same)
- ldpi (same)
- mdpi (same)
- tvdpi (same)
- xhdpi (same)
- xxhdpi (same)
- xxxhdpi (same)

#### Base APK
APK file size: 11 MiB (old), 11 MiB (new), **4 bytes** (Removed)
APK download size (estimated): 10 MiB (old), 10 MiB (new), **3 bytes** (Added)

#### Configuration hdpi
APK file size: 43 KiB (old), 43 KiB (new), **0 bytes** (No change)
APK download size (estimated): 17 KiB (old), 17 KiB (new), **0 bytes** (No change)

#### Configuration ldpi
APK file size: 44 KiB (old), 44 KiB (new), **0 bytes** (No change)
APK download size (estimated): 13 KiB (old), 13 KiB (new), **0 bytes** (No change)

#### Configuration mdpi
APK file size: 38 KiB (old), 38 KiB (new), **0 bytes** (No change)
APK download size (estimated): 13 KiB (old), 13 KiB (new), **0 bytes** (No change)

#### Configuration tvdpi
APK file size: 73 KiB (old), 73 KiB (new), **0 bytes** (No change)
APK download size (estimated): 27 KiB (old), 27 KiB (new), **0 bytes** (No change)

#### Configuration xhdpi
APK file size: 50 KiB (old), 50 KiB (new), **0 bytes** (No change)
APK download size (estimated): 20 KiB (old), 20 KiB (new), **0 bytes** (No change)

#### Configuration xxhdpi
APK file size: 55 KiB (old), 55 KiB (new), **0 bytes** (No change)
APK download size (estimated): 28 KiB (old), 28 KiB (new), **0 bytes** (No change)

#### Configuration xxxhdpi
APK file size: 55 KiB (old), 55 KiB (new), **0 bytes** (No change)
APK download size (estimated): 27 KiB (old), 27 KiB (new), **0 bytes** (No change)
</details></details>

## Beta

<details><summary>Expand to see flavor specifics</summary>

### Universal APK
APK file size: 11 MiB (old), 11 MiB (new), **4 bytes** (Added)

APK download size (estimated): 10 MiB (old), 10 MiB (new), **26 bytes** (Removed)

Method count: 115873 (old), 115873 (new), **0** (No change)

Features: 2 (old), 2 (new), **0** (No change)

Permissions: 6 (old), 6 (new), **0** (No change)

Resources: 5800 (old), 5800 (new), **0** (No change)
- Anim: 33 (old), 33 (new), **0** (No change)
- Animator: 24 (old), 24 (new), **0** (No change)
- Array: 14 (old), 14 (new), **0** (No change)
- Attr: 888 (old), 888 (new), **0** (No change)
- Bool: 8 (old), 8 (new), **0** (No change)
- Color: 820 (old), 820 (new), **0** (No change)
- Dimen: 780 (old), 780 (new), **0** (No change)
- Drawable: 342 (old), 342 (new), **0** (No change)
- Id: 1231 (old), 1231 (new), **0** (No change)
- Integer: 32 (old), 32 (new), **0** (No change)
- Interpolator: 11 (old), 11 (new), **0** (No change)
- Layout: 343 (old), 343 (new), **0** (No change)
- Menu: 1 (old), 1 (new), **0** (No change)
- Mipmap: 1 (old), 1 (new), **0** (No change)
- Plurals: 10 (old), 10 (new), **0** (No change)
- String: 788 (old), 788 (new), **0** (No change)
- Style: 473 (old), 473 (new), **0** (No change)
- Xml: 1 (old), 1 (new), **0** (No change)

Lesson assets: 111 (old), 111 (new), **0** (No change)

### AAB differences
<details><summary>Expand to see AAB specifics</summary>

Supported configurations:
- hdpi (same)
- ldpi (same)
- mdpi (same)
- tvdpi (same)
- xhdpi (same)
- xxhdpi (same)
- xxxhdpi (same)

#### Base APK
APK file size: 10 MiB (old), 10 MiB (new), **4 bytes** (Added)
APK download size (estimated): 9 MiB (old), 9 MiB (new), **7 bytes** (Added)

#### Configuration hdpi
APK file size: 43 KiB (old), 43 KiB (new), **0 bytes** (No change)
APK download size (estimated): 17 KiB (old), 17 KiB (new), **0 bytes** (No change)

#### Configuration ldpi
APK file size: 44 KiB (old), 44 KiB (new), **0 bytes** (No change)
APK download size (estimated): 13 KiB (old), 13 KiB (new), **0 bytes** (No change)

#### Configuration mdpi
APK file size: 38 KiB (old), 38 KiB (new), **0 bytes** (No change)
APK download size (estimated): 13 KiB (old), 13 KiB (new), **0 bytes** (No change)

#### Configuration tvdpi
APK file size: 73 KiB (old), 73 KiB (new), **0 bytes** (No change)
APK download size (estimated): 27 KiB (old), 27 KiB (new), **0 bytes** (No change)

#### Configuration xhdpi
APK file size: 50 KiB (old), 50 KiB (new), **0 bytes** (No change)
APK download size (estimated): 20 KiB (old), 20 KiB (new), **0 bytes** (No change)

#### Configuration xxhdpi
APK file size: 55 KiB (old), 55 KiB (new), **0 bytes** (No change)
APK download size (estimated): 28 KiB (old), 28 KiB (new), **0 bytes** (No change)

#### Configuration xxxhdpi
APK file size: 55 KiB (old), 55 KiB (new), **0 bytes** (No change)
APK download size (estimated): 27 KiB (old), 27 KiB (new), **0 bytes** (No change)
</details></details>

## Ga

<details><summary>Expand to see flavor specifics</summary>

### Universal APK
APK file size: 11 MiB (old), 11 MiB (new), **4 bytes** (Removed)

APK download size (estimated): 10 MiB (old), 10 MiB (new), **19 bytes** (Removed)

Method count: 115873 (old), 115873 (new), **0** (No change)

Features: 2 (old), 2 (new), **0** (No change)

Permissions: 6 (old), 6 (new), **0** (No change)

Resources: 5800 (old), 5800 (new), **0** (No change)
- Anim: 33 (old), 33 (new), **0** (No change)
- Animator: 24 (old), 24 (new), **0** (No change)
- Array: 14 (old), 14 (new), **0** (No change)
- Attr: 888 (old), 888 (new), **0** (No change)
- Bool: 8 (old), 8 (new), **0** (No change)
- Color: 820 (old), 820 (new), **0** (No change)
- Dimen: 780 (old), 780 (new), **0** (No change)
- Drawable: 342 (old), 342 (new), **0** (No change)
- Id: 1231 (old), 1231 (new), **0** (No change)
- Integer: 32 (old), 32 (new), **0** (No change)
- Interpolator: 11 (old), 11 (new), **0** (No change)
- Layout: 343 (old), 343 (new), **0** (No change)
- Menu: 1 (old), 1 (new), **0** (No change)
- Mipmap: 1 (old), 1 (new), **0** (No change)
- Plurals: 10 (old), 10 (new), **0** (No change)
- String: 788 (old), 788 (new), **0** (No change)
- Style: 473 (old), 473 (new), **0** (No change)
- Xml: 1 (old), 1 (new), **0** (No change)

Lesson assets: 111 (old), 111 (new), **0** (No change)

### AAB differences
<details><summary>Expand to see AAB specifics</summary>

Supported configurations:
- hdpi (same)
- ldpi (same)
- mdpi (same)
- tvdpi (same)
- xhdpi (same)
- xxhdpi (same)
- xxxhdpi (same)

#### Base APK
APK file size: 10 MiB (old), 10 MiB (new), **4 bytes** (Removed)
APK download size (estimated): 9 MiB (old), 9 MiB (new), **19 bytes** (Removed)

#### Configuration hdpi
APK file size: 43 KiB (old), 43 KiB (new), **0 bytes** (No change)
APK download size (estimated): 17 KiB (old), 17 KiB (new), **0 bytes** (No change)

#### Configuration ldpi
APK file size: 44 KiB (old), 44 KiB (new), **0 bytes** (No change)
APK download size (estimated): 13 KiB (old), 13 KiB (new), **0 bytes** (No change)

#### Configuration mdpi
APK file size: 38 KiB (old), 38 KiB (new), **0 bytes** (No change)
APK download size (estimated): 13 KiB (old), 13 KiB (new), **0 bytes** (No change)

#### Configuration tvdpi
APK file size: 73 KiB (old), 73 KiB (new), **0 bytes** (No change)
APK download size (estimated): 27 KiB (old), 27 KiB (new), **0 bytes** (No change)

#### Configuration xhdpi
APK file size: 50 KiB (old), 50 KiB (new), **0 bytes** (No change)
APK download size (estimated): 20 KiB (old), 20 KiB (new), **0 bytes** (No change)

#### Configuration xxhdpi
APK file size: 55 KiB (old), 55 KiB (new), **0 bytes** (No change)
APK download size (estimated): 28 KiB (old), 28 KiB (new), **0 bytes** (No change)

#### Configuration xxxhdpi
APK file size: 55 KiB (old), 55 KiB (new), **0 bytes** (No change)
APK download size (estimated): 27 KiB (old), 27 KiB (new), **0 bytes** (No change)
</details></details>
author_association: NONE
user: login: github-actions[bot]
created_at: 2025-03-21T03:50:29Z
body: # APK & AAB differences analysis
Note that this is a summarized snapshot. See the CI artifacts for detailed differences.

## Dev

<details><summary>Expand to see flavor specifics</summary>

### Universal APK
APK file size: 19 MiB (old), 19 MiB (new), **1052 bytes** (Removed)

APK download size (estimated): 17 MiB (old), 17 MiB (new), **992 bytes** (Removed)

Method count: 260454 (old), 260423 (new), **31** (Removed)

Features: 2 (old), 2 (new), **0** (No change)

Permissions: 6 (old), 6 (new), **0** (No change)

Resources: 6832 (old), 6832 (new), **0** (No change)
- Anim: 43 (old), 43 (new), **0** (No change)
- Animator: 26 (old), 26 (new), **0** (No change)
- Array: 15 (old), 15 (new), **0** (No change)
- Attr: 922 (old), 922 (new), **0** (No change)
- Bool: 9 (old), 9 (new), **0** (No change)
- Color: 967 (old), 967 (new), **0** (No change)
- Dimen: 1048 (old), 1048 (new), **0** (No change)
- Drawable: 380 (old), 380 (new), **0** (No change)
- Id: 1285 (old), 1285 (new), **0** (No change)
- Integer: 37 (old), 37 (new), **0** (No change)
- Interpolator: 11 (old), 11 (new), **0** (No change)
- Layout: 380 (old), 380 (new), **0** (No change)
- Menu: 3 (old), 3 (new), **0** (No change)
- Mipmap: 1 (old), 1 (new), **0** (No change)
- Plurals: 10 (old), 10 (new), **0** (No change)
- Raw: 2 (old), 2 (new), **0** (No change)
- String: 855 (old), 855 (new), **0** (No change)
- Style: 832 (old), 832 (new), **0** (No change)
- Xml: 6 (old), 6 (new), **0** (No change)

Lesson assets: 111 (old), 111 (new), **0** (No change)

### AAB differences
<details><summary>Expand to see AAB specifics</summary>

Supported configurations:
- hdpi (same)
- ldpi (same)
- mdpi (same)
- tvdpi (same)
- xhdpi (same)
- xxhdpi (same)
- xxxhdpi (same)

#### Base APK
APK file size: 18 MiB (old), 18 MiB (new), **1052 bytes** (Removed)
APK download size (estimated): 17 MiB (old), 17 MiB (new), **1118 bytes** (Removed)
Method count: 260454 (old), 260423 (new), **31** (Removed)

#### Configuration hdpi
APK file size: 50 KiB (old), 50 KiB (new), **0 bytes** (No change)
APK download size (estimated): 18 KiB (old), 18 KiB (new), **0 bytes** (No change)

#### Configuration ldpi
APK file size: 49 KiB (old), 49 KiB (new), **0 bytes** (No change)
APK download size (estimated): 14 KiB (old), 14 KiB (new), **0 bytes** (No change)

#### Configuration mdpi
APK file size: 45 KiB (old), 45 KiB (new), **0 bytes** (No change)
APK download size (estimated): 14 KiB (old), 14 KiB (new), **0 bytes** (No change)

#### Configuration tvdpi
APK file size: 86 KiB (old), 86 KiB (new), **0 bytes** (No change)
APK download size (estimated): 29 KiB (old), 29 KiB (new), **0 bytes** (No change)

#### Configuration xhdpi
APK file size: 57 KiB (old), 57 KiB (new), **0 bytes** (No change)
APK download size (estimated): 21 KiB (old), 21 KiB (new), **0 bytes** (No change)

#### Configuration xxhdpi
APK file size: 63 KiB (old), 63 KiB (new), **0 bytes** (No change)
APK download size (estimated): 29 KiB (old), 29 KiB (new), **0 bytes** (No change)

#### Configuration xxxhdpi
APK file size: 63 KiB (old), 63 KiB (new), **0 bytes** (No change)
APK download size (estimated): 28 KiB (old), 28 KiB (new), **0 bytes** (No change)
</details></details>

## Alpha

<details><summary>Expand to see flavor specifics</summary>

### Universal APK
APK file size: 11 MiB (old), 11 MiB (new), **1156 bytes** (Removed)

APK download size (estimated): 10 MiB (old), 10 MiB (new), **1467 bytes** (Removed)

Method count: 115881 (old), 115867 (new), **14** (Removed)

Features: 2 (old), 2 (new), **0** (No change)

Permissions: 6 (old), 6 (new), **0** (No change)

Resources: 5800 (old), 5800 (new), **0** (No change)
- Anim: 33 (old), 33 (new), **0** (No change)
- Animator: 24 (old), 24 (new), **0** (No change)
- Array: 14 (old), 14 (new), **0** (No change)
- Attr: 888 (old), 888 (new), **0** (No change)
- Bool: 8 (old), 8 (new), **0** (No change)
- Color: 820 (old), 820 (new), **0** (No change)
- Dimen: 780 (old), 780 (new), **0** (No change)
- Drawable: 342 (old), 342 (new), **0** (No change)
- Id: 1231 (old), 1231 (new), **0** (No change)
- Integer: 32 (old), 32 (new), **0** (No change)
- Interpolator: 11 (old), 11 (new), **0** (No change)
- Layout: 343 (old), 343 (new), **0** (No change)
- Menu: 1 (old), 1 (new), **0** (No change)
- Mipmap: 1 (old), 1 (new), **0** (No change)
- Plurals: 10 (old), 10 (new), **0** (No change)
- String: 788 (old), 788 (new), **0** (No change)
- Style: 473 (old), 473 (new), **0** (No change)
- Xml: 1 (old), 1 (new), **0** (No change)

Lesson assets: 111 (old), 111 (new), **0** (No change)

### AAB differences
<details><summary>Expand to see AAB specifics</summary>

Supported configurations:
- hdpi (same)
- ldpi (same)
- mdpi (same)
- tvdpi (same)
- xhdpi (same)
- xxhdpi (same)
- xxxhdpi (same)

#### Base APK
APK file size: 11 MiB (old), 11 MiB (new), **1156 bytes** (Removed)
APK download size (estimated): 10 MiB (old), 10 MiB (new), **875 bytes** (Removed)
Method count: 115881 (old), 115867 (new), **14** (Removed)

#### Configuration hdpi
APK file size: 43 KiB (old), 43 KiB (new), **0 bytes** (No change)
APK download size (estimated): 17 KiB (old), 17 KiB (new), **0 bytes** (No change)

#### Configuration ldpi
APK file size: 44 KiB (old), 44 KiB (new), **0 bytes** (No change)
APK download size (estimated): 13 KiB (old), 13 KiB (new), **0 bytes** (No change)

#### Configuration mdpi
APK file size: 38 KiB (old), 38 KiB (new), **0 bytes** (No change)
APK download size (estimated): 13 KiB (old), 13 KiB (new), **0 bytes** (No change)

#### Configuration tvdpi
APK file size: 73 KiB (old), 73 KiB (new), **0 bytes** (No change)
APK download size (estimated): 27 KiB (old), 27 KiB (new), **0 bytes** (No change)

#### Configuration xhdpi
APK file size: 50 KiB (old), 50 KiB (new), **0 bytes** (No change)
APK download size (estimated): 20 KiB (old), 20 KiB (new), **0 bytes** (No change)

#### Configuration xxhdpi
APK file size: 55 KiB (old), 55 KiB (new), **0 bytes** (No change)
APK download size (estimated): 28 KiB (old), 28 KiB (new), **0 bytes** (No change)

#### Configuration xxxhdpi
APK file size: 55 KiB (old), 55 KiB (new), **0 bytes** (No change)
APK download size (estimated): 27 KiB (old), 27 KiB (new), **0 bytes** (No change)
</details></details>

## Beta

<details><summary>Expand to see flavor specifics</summary>

### Universal APK
APK file size: 11 MiB (old), 11 MiB (new), **1012 bytes** (Removed)

APK download size (estimated): 10 MiB (old), 10 MiB (new), **2660 bytes** (Removed)

Method count: 115887 (old), 115873 (new), **14** (Removed)

Features: 2 (old), 2 (new), **0** (No change)

Permissions: 6 (old), 6 (new), **0** (No change)

Resources: 5800 (old), 5800 (new), **0** (No change)
- Anim: 33 (old), 33 (new), **0** (No change)
- Animator: 24 (old), 24 (new), **0** (No change)
- Array: 14 (old), 14 (new), **0** (No change)
- Attr: 888 (old), 888 (new), **0** (No change)
- Bool: 8 (old), 8 (new), **0** (No change)
- Color: 820 (old), 820 (new), **0** (No change)
- Dimen: 780 (old), 780 (new), **0** (No change)
- Drawable: 342 (old), 342 (new), **0** (No change)
- Id: 1231 (old), 1231 (new), **0** (No change)
- Integer: 32 (old), 32 (new), **0** (No change)
- Interpolator: 11 (old), 11 (new), **0** (No change)
- Layout: 343 (old), 343 (new), **0** (No change)
- Menu: 1 (old), 1 (new), **0** (No change)
- Mipmap: 1 (old), 1 (new), **0** (No change)
- Plurals: 10 (old), 10 (new), **0** (No change)
- String: 788 (old), 788 (new), **0** (No change)
- Style: 473 (old), 473 (new), **0** (No change)
- Xml: 1 (old), 1 (new), **0** (No change)

Lesson assets: 111 (old), 111 (new), **0** (No change)

### AAB differences
<details><summary>Expand to see AAB specifics</summary>

Supported configurations:
- hdpi (same)
- ldpi (same)
- mdpi (same)
- tvdpi (same)
- xhdpi (same)
- xxhdpi (same)
- xxxhdpi (same)

#### Base APK
APK file size: 10 MiB (old), 10 MiB (new), **1012 bytes** (Removed)
APK download size (estimated): 9 MiB (old), 9 MiB (new), **1490 bytes** (Removed)
Method count: 115887 (old), 115873 (new), **14** (Removed)

#### Configuration hdpi
APK file size: 43 KiB (old), 43 KiB (new), **0 bytes** (No change)
APK download size (estimated): 17 KiB (old), 17 KiB (new), **0 bytes** (No change)

#### Configuration ldpi
APK file size: 44 KiB (old), 44 KiB (new), **0 bytes** (No change)
APK download size (estimated): 13 KiB (old), 13 KiB (new), **0 bytes** (No change)

#### Configuration mdpi
APK file size: 38 KiB (old), 38 KiB (new), **0 bytes** (No change)
APK download size (estimated): 13 KiB (old), 13 KiB (new), **0 bytes** (No change)

#### Configuration tvdpi
APK file size: 73 KiB (old), 73 KiB (new), **0 bytes** (No change)
APK download size (estimated): 27 KiB (old), 27 KiB (new), **0 bytes** (No change)

#### Configuration xhdpi
APK file size: 50 KiB (old), 50 KiB (new), **0 bytes** (No change)
APK download size (estimated): 20 KiB (old), 20 KiB (new), **0 bytes** (No change)

#### Configuration xxhdpi
APK file size: 55 KiB (old), 55 KiB (new), **0 bytes** (No change)
APK download size (estimated): 28 KiB (old), 28 KiB (new), **0 bytes** (No change)

#### Configuration xxxhdpi
APK file size: 55 KiB (old), 55 KiB (new), **0 bytes** (No change)
APK download size (estimated): 27 KiB (old), 27 KiB (new), **0 bytes** (No change)
</details></details>

## Ga

<details><summary>Expand to see flavor specifics</summary>

### Universal APK
APK file size: 11 MiB (old), 11 MiB (new), **1044 bytes** (Removed)

APK download size (estimated): 10 MiB (old), 10 MiB (new), **3988 bytes** (Removed)

Method count: 115887 (old), 115873 (new), **14** (Removed)

Features: 2 (old), 2 (new), **0** (No change)

Permissions: 6 (old), 6 (new), **0** (No change)

Resources: 5800 (old), 5800 (new), **0** (No change)
- Anim: 33 (old), 33 (new), **0** (No change)
- Animator: 24 (old), 24 (new), **0** (No change)
- Array: 14 (old), 14 (new), **0** (No change)
- Attr: 888 (old), 888 (new), **0** (No change)
- Bool: 8 (old), 8 (new), **0** (No change)
- Color: 820 (old), 820 (new), **0** (No change)
- Dimen: 780 (old), 780 (new), **0** (No change)
- Drawable: 342 (old), 342 (new), **0** (No change)
- Id: 1231 (old), 1231 (new), **0** (No change)
- Integer: 32 (old), 32 (new), **0** (No change)
- Interpolator: 11 (old), 11 (new), **0** (No change)
- Layout: 343 (old), 343 (new), **0** (No change)
- Menu: 1 (old), 1 (new), **0** (No change)
- Mipmap: 1 (old), 1 (new), **0** (No change)
- Plurals: 10 (old), 10 (new), **0** (No change)
- String: 788 (old), 788 (new), **0** (No change)
- Style: 473 (old), 473 (new), **0** (No change)
- Xml: 1 (old), 1 (new), **0** (No change)

Lesson assets: 111 (old), 111 (new), **0** (No change)

### AAB differences
<details><summary>Expand to see AAB specifics</summary>

Supported configurations:
- hdpi (same)
- ldpi (same)
- mdpi (same)
- tvdpi (same)
- xhdpi (same)
- xxhdpi (same)
- xxxhdpi (same)

#### Base APK
APK file size: 10 MiB (old), 10 MiB (new), **1044 bytes** (Removed)
APK download size (estimated): 9 MiB (old), 9 MiB (new), **2642 bytes** (Removed)
Method count: 115887 (old), 115873 (new), **14** (Removed)

#### Configuration hdpi
APK file size: 43 KiB (old), 43 KiB (new), **0 bytes** (No change)
APK download size (estimated): 17 KiB (old), 17 KiB (new), **0 bytes** (No change)

#### Configuration ldpi
APK file size: 44 KiB (old), 44 KiB (new), **0 bytes** (No change)
APK download size (estimated): 13 KiB (old), 13 KiB (new), **0 bytes** (No change)

#### Configuration mdpi
APK file size: 38 KiB (old), 38 KiB (new), **0 bytes** (No change)
APK download size (estimated): 13 KiB (old), 13 KiB (new), **0 bytes** (No change)

#### Configuration tvdpi
APK file size: 73 KiB (old), 73 KiB (new), **0 bytes** (No change)
APK download size (estimated): 27 KiB (old), 27 KiB (new), **0 bytes** (No change)

#### Configuration xhdpi
APK file size: 50 KiB (old), 50 KiB (new), **0 bytes** (No change)
APK download size (estimated): 20 KiB (old), 20 KiB (new), **0 bytes** (No change)

#### Configuration xxhdpi
APK file size: 55 KiB (old), 55 KiB (new), **0 bytes** (No change)
APK download size (estimated): 28 KiB (old), 28 KiB (new), **0 bytes** (No change)

#### Configuration xxxhdpi
APK file size: 55 KiB (old), 55 KiB (new), **0 bytes** (No change)
APK download size (estimated): 27 KiB (old), 27 KiB (new), **0 bytes** (No change)
</details></details>
author_association: NONE
user: login: oppiabot[bot]
created_at: 2025-03-26T00:02:59Z
body: Unassigning @BenHenning since they have already approved the PR.
author_association: NONE
user: login: oppiabot[bot]
created_at: 2025-03-26T00:03:02Z
body: Hi @adhiamboperes, this PR is ready to be merged. Please address any remaining comments prior to merging, and feel free to merge this PR once the CI checks pass and you're happy with it. Thanks!
author_association: NONE
user: login: adhiamboperes
created_at: 2025-03-26T23:11:46Z
body: Thanks @TanishMoral11, @theayushyadav11, @subhajitxyz for your reviews! I have addressed all of your comments.

You should be able to view the latest changes only by clicking on `New changes since you last viewed` near the bottom of the PR page.

Also, I have enabled auto-merge as I have self-reviewed all the chnages.  
author_association: CONTRIBUTOR