Firefox Android编译入门指导


This page covers the basic steps needed to build a bleeding-edge, development version of Firefox for Android, also known as Fennec.Welcome, we're delighted to see you! :)

If you're having trouble following this documentation or hit a roadblock you can't get around, please contact Nick Alexander at directly so we can solve the problem for you and every new contributor after you.

更多详细参考 Firefox for Android wikibuild documentation.


在折腾Firefox Android代码(代号:Fennec)之前,你需要准备三样东西 :

  • 一台电脑,运行 Linux 或 OSX ,至少 30Gb 储存空间,
  • 一台Android设备(或者虚拟设备)
  • 可用的网络.

电脑需要是 64-bit 的 基于Unix的操作系统; 目前为止, 在Windows 编译还未被支持. 你可以输入如下命令确认操作系统是否为 64-bit:

uname -m

... 回车之后, 如果看到 "x86_64" ,那么可以进行下一步了.

Fennec基本上可以在4年内生产的 Android 设备上运行. 旧的机器,如使用ARMv6 芯片或者更旧可能不被支持.

如果你的电脑和android 设备都准备好的话,那么可以开始了!

Android 设备的设置.

为了更好的调试和运行,请打开 "设置", 选择 "关于" ,为了激活 "开发者模式",点按 "版本号"7次 ,那么"开发者选项"就会出现在"设置" 菜单中 .




这里需要下载大量的数据, 需要注意你的网速和网络稳定型.

  • 在主文件夹打开终端.
  • 创建 src/ 文件夹, 是这个项目的工作目录.
  • 下载 并保存 src/
  • 切换到 src/ 目录, 在终端运行命令
  • ... 然后根据你需求选择 "Firefox for Android". 这个脚本为你完成剩下的事情. 如果你想了解 都做了什么,你可以点击这里 detailed setup instructions.

Setting yourself up.

That last step can take some time. While it’s finishing, take a moment to sign up for a Bugzilla account! is Mozilla’s issue tracker. To comment on a bug or submit a patch you’ll need a Bugzilla account, so sign up for one now!

As well as Bugzilla, much of Mozilla’s internal communication happens over IRC. You can download Limechat here, and learn how to connect to Mozilla with IRC here. If you’re just getting started or have questions about getting set up you can join us in the #introduction channel, where some of our community members hang out to try and help new contributors get rolling.


这是一个耗时的步骤, 在 src/ 目录下, 运行命令:

hg clone

... 回车. 这里使用mercurial 版本控制工具从Mozilla-Central下载Firefox代码.

While you’re waiting for that process to finish, take a look at our Mercurial documentation. It explains how we use version control at Mozilla to manage our code and land changes to our source tree.


bootstrap 脚本应该在内容写入到 mozconfig 文件中了. 如果并没有, 或者你想重新设置, 可以在这里找到详细的配置设置:

(Note: if you don't configure the build with a mozconfig, then you will end up producing a desktop build of Firefox.)


一切准备好后,切换到你的源代码目录 (~/src/mozilla-central/),敲入命令

mach build



There’s one more thing you can do for yourself while you’re waiting: create an account for yourself on Mozillians.

Mozillians is the Mozilla community directory, where you can connect with people who share your interests, projects or countries. This step is optional, but we think it will be worth your while.


确保你的Android 设备数据线已经插在电脑上了, 敲击这两个命令打包和安装:

mach package

mach install

Now the fun starts.

You’re ready to start hacking. You have the code, you’ve compiled Firefox, and it’s running on your phone. The next steps are up to you: join us on IRC in#introduction and find yourself a bug to start work on!

Thank you

Mozilla's strength is the community behind it; Firefox is the product of a global development team working to keep the Web free, open and participatory, and your contributions will make Firefox and the Web better for hundreds of millions of people around the world.


目前为止,只能在类UNIX的系统上编译Firefox for Android , 包括Mac OS X 和大部分的Linux系统. 大部分开发者使用 Mac OS X;少部分 Linux.

Building Firefox for Android on Microsoft Windows is not yet supported.  There is no hard reason that it should not be possible (now; in the past, it was not possible because Google did not release certain parts of the Android toolchain for Windows), but it's also not a priority. If you're interested in building on Windows, or can contribute, please CC yourself onto bug 1169873.

Hardware requirements

  • While you can build Firefox on older hardware, it can take quite a bit of time to compile on slower machines. Having at least 8GB of RAM is recommended.
  • If you have older hardware, it is strongly recommended that you use artifact mode.
  • Fast broadband internet is strongly recommended as well. Both the development environment, and the source code repository, are quite large. Artifact mode regularly downloads large (50MB) binary archives.
  • You must have a 64-bit operating system. As of early 2015 it is no longer possible to build Firefox on most 32-bit machines.
  • If you're going to install Firefox for Android on a physical Android device, you'll need one running Android Ice Cream Sandwich (API 15) or later.
  • You can also develop against an emulator; see MozillaWiki for more details. All the mach commands discussed on this page should work with an emulated Android device the same as on physical hardware.

Bootstrap dependencies

Run either of the following in a terminal.  You'll need Python version 2.7 or later, and curl or wget.  If you have curl installed (note that Mac OS X ships curl by default):

curl -O && python

Or, if you have wget installed instead:

wget -q && python

Choose Firefox for Android when prompted.  The bootstrapping script will install system packages, the Android SDK (and NDK, if required), and the currently required versions of the Android platform and extras.

The bootstrap script will print out configuration options for you when it finishes more on this below.  For now, copy this configuration text and continue on.  You can re-run the bootstrap script to print this information again later.

Once you have all the dependencies installed, you need to clone the Firefox repository.

Get the source

Get the latest source code from Mozilla's Mercurial code repository. This may take a while; it's a lot of code!  We recommend that you add the progress extension to your Mercurial configuration.  This will provide feedback during the lengthy clone process.  See the documentation explaining how to enable the Mercurial progress extension.

hg clone

If you are using a slow or unreliable internet connection, hg clone might fail because it gets interrupted. In that case, you are strongly encouraged to download a Mercurial bundle file instead of waiting for hg clone.

Choose what parts of Firefox for Android you want to modify

Firefox for Android is built in two layers.  The Firefox for Android “front-end” — which includes the home panels, UI for settings, menus, etc., Firefox Sync, and most data storage — is implemented using Java, the Android Platform SDK, JavaScript, HTML, and CSS.  Firefox for Android is built on top of the Gecko platform back-end. Gecko is Mozilla's web rendering engine, similar to Edge, Blink, and WebKit, and is responsible for rendering web content, running JavaScript code, and providing web APIs to pages. Gecko is implemented using C++ and JavaScript.

Here is a table summarizing the pros and cons of working on the different parts.

Configuration Restrictions Implementation languages Build speed Integrated development environment
front-end Can only modify main UI, not web platform Java, JavaScript Fast builds Android Studio or IDEA IntelliJ
back-end None: can modify everything C++, JavaScript Slow builds None: use your text editor

Do you want to modify just Firefox for Android, or do you want to modify the Gecko platform?

If you don't know what you want, start with just the Firefox for Android front-end: your build times will be much shorter if you don't build the Gecko back-end as well.

But don't worry! You can always add the back-end configuration later, and it's easy to switch between the configurations.

Prepare a Firefox for Android mozconfig

The build scripts will read from the mozconfig file in your source directory (where you cloned the mozilla-central source repository into) to determine what kind of build to produce, although you can configure this if you need to.  You must use $HOME instead of ~ in your mozconfig because ~ does not get expanded.

By default, the build system creates a build of Firefox for Android roughly equivalent to the official Firefox for Android Nightly builds. If that's not exactly what you want, there are many build configuration options to choose from. It's strongly recommended that you only use options that you fully understand.

I want to work on the front-end

Firefox for Android supports a fast build mode called artifact mode.  (Some mobile team managers call it manager mode since it's particularly helpful if you only write code infrequently.)  Artifact mode downloads pre-built C++ components rather than building them locally, trading bandwidth for time.

To use artifact mode, paste the following into your mozconfig file:

# Build Firefox for Android:
ac_add_options --enable-application=mobile/android
ac_add_options --target=arm-linux-androideabi

# With the following Android SDK:
ac_add_options --with-android-sdk="/absolute/path/to/android-sdk"

# Enable artifact building:
ac_add_options --enable-artifact-builds

# Write build artifacts to:
mk_add_options MOZ_OBJDIR=./objdir-frontend

You should be ready to build with artifact mode!

I want to work on the back-end

Paste the following into your mozconfig file:

# Build Firefox for Android:
ac_add_options --enable-application=mobile/android
ac_add_options --target=arm-linux-androideabi

# With the following Android SDK and NDK:
ac_add_options --with-android-sdk="/absolute/path/to/android-sdk"
ac_add_options --with-android-ndk="/absolute/path/to/android-ndk-r11c" 

# Write build artifacts to:
mk_add_options MOZ_OBJDIR=./objdir-droid

Ensure that Android NDK you've specified (r11c in the example above) matches what you have installed locally.

If you're planning on hacking the C/C++ code, you probably want to create a debug build instead of a release build.  Add the following lines to your mozconfig:

ac_add_options --enable-debug
ac_add_options --enable-debug-symbols

Configuration options

I want to build an x86 version of Firefox for Android

Note: Only API 15+ are supported on x86 architecture.

Note: Hardware acceleration for Android emulators may not work within virtual machine even if nested virtualization is enabled.

Version 23 and later Android x86 emulators with hardware acceleration are fast enough for local development.  They're an attractive alternative if you have recent hardware and an old Android device (or no Android device).  Both artifact mode and regular mode support building APKs for x86 architectures.  Just replace the line ac_add_options --target=arm-linux-androideabi with:

ac_add_options --target=i386-linux-android

(You probably want to change the MOZ_OBJDIR directory, too.)  Now when you build, you should produce an x86 version of Firefox for Android!

For more configuration options, see the general Firefox documentation on configuring build options.

Deploy Firefox to an Android device

Quick start

The bare minimum: run these commands to build, package, install, and run a fresh Firefox for Android on your Android device.

./mach build
./mach package
./mach install
./mach run


Enter the mozilla-central subdirectory (created by the hg clone command).

To build Firefox for Android (compile and link all C/C++, Java, and JavaScript source code), run:

./mach build

Building can take a significant amount of time, depending on your hardware, OS, and chosen build options. Linux builds on a fast box may take under 15 minutes, but builds on a slow machine may take several hours. If you're using artifact mode, builds should take less than five minutes. See tips for making builds faster.

The first time you run mach build, mach will ask you if you'd like to create a .mozbuild directory in your home folder and wait 20 seconds for your answer. This a good default location and you should allow it to create the directory.


To build after making changes, run:

./mach build

This will only rebuild what is necessary for these changes. It is also possible to use:

./mach build mobile/android

This will build any altered Firefox for Android front-end code. If you are using artifact mode, this should always work. If you are building the Gecko back-end, this may yield incorrect results, so it is not recommended.


Running an Android application on a device is a little more involved than running a Desktop Firefox binary.  First, we need to package everything into an Android package.  To produce an APK, run

If you're using artifact mode, run:

./mach package

The produced APK file can be found in your $OBJDIR/dist folder, and will be called something like

Install and run

To install the Android package to your device and launch it, connect your Android device and enable USB debugging, and then run

./mach install
./mach run

The name of the App that appears on your Android device will be "Fennec $USER", where $USER is the username under which you built the code.

Note that you will need a device running Android Ice Cream Sandwich (API 15) or later.


You can use the standard mach xpcshell-test and friends when developing for Android. However, running xpcshell/cppshell tests is not currently supported on Android 6 or higher. (If you try, you will get error messages like "error: only position independent executables (PIE) are supported".) You can run ./mach android-emulator to bring up Android 4.3, which is what we run tests against on treeherder. (Just don't try with ./mach android-emulator --version 6.0, for the same reason.)

Developing Firefox for Android in Android Studio or IDEA IntelliJ

The Firefox for Android front-end team develop the product in IDEA IntelliJ (both Community and Ultimate Editions) and Android Studio.  There is a Gradle build configuration, parallel to the mach build configuration.  Eventually, we intend to use Gradle in the mach build configuration.

The Gradle configuration is now "in the source directory".  To verify that everything is working, ensure that you've built and packaged successfully, and then run:

./gradlew clean app:assembleLocalOldDebug

Next, simply import the top source directory (mozilla-central, as produced by hg clone) into your IDE.  This depends on the IDE; in Android Studio, it looks like:

Choose "Import from Gradle".

Choose the top source directory.

The IDE shows several projects after importing the top source directory.


In IDEA IntelliJ, it looks like:

  • File > Import Project... and select /path/to/mozilla-central.
  • Select Import project from external model > Gradle > Next.
  • Select Use default gradle wrapper > Finish.

You should have a shiny new Gradle-based project in your IDE! Try it out by choosing Build > Rebuild project.

Setting the Run/Debug Configuration and Build Variant

The Gradle build configuration may contain more than one Gradle module, which can define many Run/Debug Configurations.  You want the "app" Run Configuration:

Choose "app" from the Run Configurations list.

See the IntelliJ documentation for more.

The configuration also defines multiple Product Flavors, which contribute to Build Variants.  You want:

Testing device or emulator Android API Product Flavor Build Variant
>=21 local localDebug
<21 localOld localOldDebug

Choose "local" if you have an Android 21+ device; choose "localOld" if you have an Android &lt;21 device.

See the Google build documentation for more.

Things that are supported in the IDE

  • Running, debugging, and profiling Firefox for Android in the IDE.  The app project defines the Android Application.
  • Editing Java source code under mobile/android.  Modifications to any of the Java code should prompt a fresh build and install.
  • Editing Android resources under mobile/android, including in mobile/android/base/resources.  In many cases the Android Layout Editor is fully functional.
  • Modifying the Android string definitions in mobile/android/base/ and mobile/android/base/locales/en-US/*.dtd.  Modifications should be picked up at the next build; they may not be noticed automatically.  (This is because the Android strings.xml file is generated, and the generation only happens in response to a build.)
  • Editing "omnijar" JavaScript source code under mobile/android, including in mobile/android/content, mobile/android/components, and mobile/android/modules, and under toolkit/.  Modifications to JavaScript code should be picked up at the next build.  Such modifications should rebuild the omnijar and prompt a fresh build and install.
  • Editing "omnijar" chrome XHTML, CSS, and JS resources under mobile/android, including in mobile/android/content, and under toolkit/.

Things that are not supported in the IDE

  • Modifying build system configuration and definitions and modifying mobile/android/base/ or the sub-manifests.  See bug 1221344 for an example of what can go wrong here.
  • Modifying generated Java code such as mobile/android/base/java/org/mozilla/gecko/
  • Modifying C++ source code anywhere in the tree.
  • Modifying "omnijar" JavaScript source code outside of mobile/android.  (If you modify JavaScript outside of mobile/android, say under dom/, the changes will be recognized the next time "omnijar" files inside mobile/android are edited.)
  • Running Robocop tests.  (Use mach robocop to run these tests locally.)
  • Running mochitest-chrome tests.  (Use mach test to run these tests locally.)


  • First, check if the Gradle configuration is working:

    ./gradlew clean app:assembleLocalOldDebug

    That should complete successfully.

  • Second, check that you're building the correct Gradle module and the correct build variant. If you see a runtime error like

    A/GeckoLoader: Couldn't load mozglue. Trying native library dir.
    A/GeckoLoader: Library doesn't exist when it should.
    then you are probably running the "automation" Build Variant.  See the documentation on Build Variants and the discussion in bug 1246055.
  • Third, ensure that you can install the APK to your device:

    ./gradlew clean app:install{Local,LocalOld}Debug

    completes successfully, where you choose "Local" or "LocalOld" depending on your target device.  See the documentation on Build Variants.

  • It's possible to confuse the IDE about the state of the source directory.  To recover, try the following:
    • Select the root project and refresh everything in the IDE.
    • Open the root build.gradle file. If the IDE warns that the Gradle configuration has changed, accept the offer to Sync now.
    • Refresh the Gradle model manually: select View > Tool Windows > Gradle and click the blue Sync button in the top left.  In Android Studio, there's an icon to do this in the main toolbar -- it's labeled Sync Project with Gradle Files.
    • Clear the IDE cache manually:  select File > Invalidate caches and then restart the IDE.  (This should never be necessary.)

Required Android SDK and NDK versions

The Fennec build system requires the following versions:

If your build fails because you're missing one of the Android or Google requirements, your first step should be to run mach bootstrap. If you don't want to run the bootstrapper, you can manually install by running the Android SDK manager: try mach android, or $ANDROID_SDK/tools/android.

Requirement Version required
Android SDK Platform Android 6.0 (API 23)
SDK Build Tools 23.0.3
SDK Platform Tools 23.0.1
Android SDK Tools 23.0.1
Android Support Repository 21 (or later)
Google Repository 22 (or later)
Android NDK r11c

bug 1207680 tracks listing these version requirements in one place in the source code.


此页面的贡献者: john0804tin, tcg2008
最后编辑者: john0804tin,