How To Port CyanogenMod Android To Your Own Device



If you came to this page by searching for information about porting Android, and you're not sure what CyanogenMod is, learn more about the CyanogenMod distribution of Android here.



Some tips on porting CyanogenMod to your own device


So you may come across a phone or tablet or whatever that does not yet have CyanogenMod available.


You've previously built CyanogenMod on your computer for another device or two, and you feel comfortable with the process. In fact, you've still got the source code standing by and are ready to tackle a big project.


Looks like this is your opportunity to shine!



For the purposes of this tutorial, all references to directories will assume you are in the root of the source code (ie, where you did the repo init), and folder names will be relative to there. If you followed the build guide, the root of the source code is at ~/android/system


在这个指导教程里面,所有对目录的提及都是假定你是在源代码的根目录(例如在你做repo init的地方),而且目录名会和那个地方有关。如果你遵循构建指导,源代码的根目录是在~/android/system



Porting CyanogenMod to a new device can be ridiculously easy or ridiculously difficult, depending on the device itself, whether it currently runs a recent version of Android or not, and of course your skills as a developer matter too.


It would be pretty hard to do a port without having built CyanogenMod (and recovery) previously for another device. So if you haven't done a build or two, give it a shot.


Helpful Tip

If you found this page other than via the CyanogenMod Learning Center, head over to Development for much more information.



Additionally, you should familiarize yourself with the 
CyanogenMod source code. You should expect that, barring some rare exceptions, nearly everything you need to do will be in the /device/[vendor]/[codename]/vendor/[vendor]/[codename], and /kernel/[vendor]/[codename] directories (which you will need to create).

另外你应该对于Cyanogenmod源代码非常熟悉。你应该知道,不包括一些罕见的例外,你需要做的几乎一切都是在/device/制造商/开发代号,/制造商/制造商/开发代号,和/kernel/制造商/开发代号 目录(你将要创建它们)。

Helpful Tip

For a more-detailed overview of what's where in the CyanogenMod source folders, see here. In fact, you really should read this if you plan on doing a port.



Collect information about your device


Before you begin your port, you will want to collect as much information about your device as you can. Go to wikipedia or XDA-Developers Wiki and identify the product name, code name , vendor codearchitecture (i.e. ARMv7), memory size, internal storage size, and platform architecture. Put this information in a file for easy retrieval. Try to learn as much about the device, including any similarities it may have to other devices (chipset common elements, i.e chip, motherboard, GPU …).


Helpful Tip

Many devices are architecturally similar to other devices that are already on the market and have existing CM ports. When a new device comes out, see if you can find out if it may be identical to another device or have the same processor (i.e. ARM processor or MediaTek motherboard) only with a different sized screen or more memory or some other minor difference. If you find an "ancestor" or "sibling" of your device, much of the work may already be done for you!



Much of the information you need may be available online, but assuming the device is already running a non-CyanogenMod version Android, you may also get some of that information from the device itself. To view the files containing this information, sometimes the device may need to be rooted . However, sometimes you can find a stock firmware update package online, and can view the files from the .zip archive file.


Look at the device's current /system/build.prop


Assuming the device is already running a version of Android, there should be a file, /system/build.prop, on the device which may contain useful information that will come into play as you do your port. This file contains definitions for various parameters and settings used by Android.


So, if you have previously installed adb onto your computer, you can use the following command to pull this file to your computer:


adb pull /system/build.prop

If you receive an error relating to permissions, the device may need to be rooted to gain access to this file. However, as said, there are other ways to locate this file. For example, it may be included in any stock firmware "upgrade" package online.


You can also use Build Prop Editor and Root Browser from here (rooting is a prerequisite to use them).

你也可以用Build Prop EditorBuild Prop Editor,点击这里(root是使用它们的前提)。

Once you have the file…


·         Write down the value of the ro.product.manufacturer parameter. This will be your vendor name. The [vendor] is the name of the manufacturer/vendor of the device. CM has established naming conventions for most major vendors, such as samsunghtclge, etc. Note that in these directory names, the vendor is always lowercase and contains no spaces.

·        写下ro.product.manufacturer参数的值。这将是你的vender的值。Vender是设备的生产商或者销售商的值。CM已经为大多数主流生厂商建立了命名协定,比如samsung,htc,lge等等。注意在这些目录名中,生厂商名小写而且没有空格的。

·         Write down the value of the ro.product.device parameter. This will be your device codename. The [codename] corresponds to the project code name of the device itself. This is almost never the sales name of the device. If you have built CM before (and again, you better have!), you should be familiar with the concept of a code name for each device. Like the vendor name, the codename is always lowercase and contains no spaces.

·        写下ro.product.device参数 的值。这是你的设备的开发代号。这个开发代号对应设备自己的项目代号名。这几乎绝不会是设备的销售名。如果你之前已经编译过CM(再一次说,你最好已经做过 了),你应该对每个设备的开发代号名这个概念很熟悉。和生产商名一样,开发代号也是小写无空格的。


Sometimes a device is identified in other parameters such as ro.product.board



Keep the build.prop file handy, as you may refer to it later.


Examine boot.img and recovery.img


As stated, when doing your port, you may wish to use an existing pre-built kernel that you know works instead of building one from source code . Depending on your device, you may need to extract this kernel file from the device. The kernel may exist as a single file (as it does on many OMAP devices) or may be wrapped up along with the ramdisk in a boot or recovery partition.


Similarly, the contents of the stock ramdisk may be extremely helpful and can often be extracted and reviewed. It may be the case that a device requires specific files from the stock ramdisk in order to boot properly, load a module, etc. In most cases you can view files in the ramdisk from the device itself, but it you may prefer to look at the full directory.



The ramdisk is a tiny group of files and directories that are loaded into memory along with the kernel. The kernel then runs one of the files in the ramdisk called init, which then runs a script (init.rcinit.[codename].rc, etc.) that in turns loads the rest of Android. The ramdisk and kernel can be packaged together in a number of different ways using tools with names like mkbootimgmkimage, and other methods.



You can frequently extract the boot and recovery images (to a file you name boot.img and recovery.img) on a rooted Android device using dd.


Or, if you have access to an update .zip file from the vendor (that could call it firmware), you can often find those files within.


Collect any available existing source code


The manufacturer or vender of any device using Android will minimally need to make the source code available for all GPL components upon request, including (and especially) the kernel. You definitely want to request a copy of the kernel source and keep it handy.


Determine the partition scheme


The primary long-term storage portion of your mobile device– usually an "emmc" (embedded multimedia card)– is much like a computer hard drive in that it is prepared in a la particular way to identify and isolate different areas of data. These unique areas are called partitions and they can have any kind of data stored there. Some partitions contain raw data — firmware , kernel s, ramdisk s, etc. More often, a partition is formatted to use a particular file system that the kernel will recognize so that individual files and directories can be read and written there.


Before you can replace the stock operating system with CyanogenMod, it is therefore important to ascertain the partition scheme of the device. The recovery image you build will need this information to know where to find the various Android directories. Particularly, you want to know which partitions are assigned to /system/data/cache, and /sdcard.

在你用Cyanogenmod代替原来的操作系统之前,确定设备的分区表是相当重要的。你构建的Recovery镜像将需要这些信息来知道在哪里发现各种安卓目录。特别是你想知道哪些分区被安排为/system, /data, /cache/sdcard

You want to know which partitions exist, on what device, how they are mounted, as well as the size of the partitions. This information may be transferred later to the BoardConfig.mk file in your /vendor directory.


If you're lucky, a recovery.fstab file can be located in a recovery.img file, speeding up the process of figuring out what goes where. Also, the init.[codename].rc file in the ramdisk may have the information. Look for the lines near the top where the partitions are mounted.


Also, the command:


$ cat /proc/partitions

from a running device can also help you identify the partitions. Also see /proc/emmc/proc/mounts or /proc/mtd. You may also get some information from the command mount (run as root ).

从一个运行的设备也能帮你识别这个分区。也可以看看/proc/emmc, /proc/mounts 或者 /proc/mtd目录。你也可以用命令mountroot权限)得到一些信息。

Also check /cache/recovery.log or /tmp/recovery.log.

也可以检查一下/cache/recovery.log 或者 /tmp/recovery.log文件

Finally, if you have source code to the bootloader (such as the u-boot used by many OMAP -based devices), you will likely find the information there as well.



Be aware that in some rare cases, such as the HP Touchpad, an abstracted virtual file system is used.


要知道在一些很罕见的情况下,例如HP Touchpad,一种VFS虚拟文件系统被使用。

Set up three new directories


Now that you've gathered information about your device, it's time to generate the folders for your device configuration, located in the following directories, relative to the code source directory.


·         device/[vendor]/[codename]/ — this is where the installation files specific to your device will go. The device/ directory contain 99-100% of the configuration settings and other code for particular devices. You'll get to know this directory pretty well. As mentioned, when starting the folder for this device, it may be a good idea to adapt a directory for an existing device that is architecturally similar to the one you wish to port. Look for a device that is based on the same platform, as ARMv7 or MediaTek chipset, for example.

·         这是和你的特定的设备有关的安装文件要去的地方。这个device文件夹包含99%100%的设置配置信息和其他针对特殊设备的代码。你将逐渐了解这个文件夹。就像之前说的一样,在为这个设备建立文件夹时,比较好的做法可能是去修改一个已存在的设备的文件夹,这个已存在的设备是和你希望移植的设备在架构上相似。寻找基于同一个平台的设备,例如使用ARMv7MTK芯片组。

·         vendor/[vendor]/[codename]/ — The vendor/ directory contains proprietary, binary "blobs" that are backed up from the original device (or provided by the vendor, such as in the case of Google Nexus devices and some TI graphics blobs).

·         vendor文件夹包含生产商专有的,从原始设备打包的二进制块文件(或者是被生产商提供的,例如Google Nexus设备和一些德州仪器的图像处理块文件)

·         kernel/[vendor]/[codename]/ — the kernel source goes here. When you first start your porting effort, you may wish to simplify things by using a pre-built kernel (such as the one that came with the stock installation) rather than building the kernel from scratch. The trick to that will be extracting the kernel out of the stock system from whatever format it may be in, and then re-packaging it, along with a new ramdisk, into a form that your device can use. This can vary from device-to-device, so it may again be helpful to look at similar devices to yours that use a similar architecture. Building the kernel from source is not strictly necessary for every device, but in the spirit of open source, it is the preferred practice for CyanogenMod. See here for a detailed discussion about how CyanogenMod builds the kernel source from scratch.

·         内核源代码在这里。在你第一次开始移植的努力的时候,你可能希望使用一个预先编译好的啮合来简化工作(例如来自一个固件安装包的内核),而不是从头开始。那样做的技巧就是从一个无论内核是什么格式的原来的系统中提取内核,然后加上一个新的内存盘来重新打包,用一个你的设备可以使用的格式。这种活可能不同的设备有不同的方式,所以再一次说明找一个有相似架构的设备是很有帮助的。用源代码重新构建内核不是对每个设备都是必要的,但是本着开源的精神,重新编译对于Cyanogenmod更好。

There are at least three methods to generate these directories:


Method 1: Use mkvendor.sh to generate skeleton files


Use the mkvendor.sh script in build/tools/device/ to automatically generate the directories.



The mkvendor script only works with devices that use a standard boot.img file, using the standard Android conventions and headers. It won't work for devices that deviate from this standard (Nook Color, Touchpad, etc.).


Mkvendor脚本只和使用标准boot.img文件的设备工作,它使用标准的安卓协定和文件头。它不会和偏离这个标准的设备工作(例如Nook ColorTouchpad等等)。

This script accepts three parameters: vendorcodename, and a boot.img file.


Example usage:


$ ./build/tools/device/mkvendor.sh samsung i9300 ~/Desktop/i9300boot.img

In the above example, samsung represents the vendori9300 represents the codename and the last parameter is the path to the boot.img file that was extracted from the boot partition with dd or provided by the vendor in an update .zip as discussed above.

在上面的例子中,samsung代表生厂商,i9300代表开发代号名,最后一个参数是到boot.img文件的路径,像上面讨论的一样,这个文件用dd命令从boot分区解压出来或者被生产商提供在一个update .zip里。

The command above should create a /device/samsung/i9300/ folder within your CyanogenMod source repo structure. And inside the folder, the files AndroidBoard.mk,AndroidProducts.mkBoardConfig.mkcm.mkdevice_[codename].mkkernel (the binary), recovery.fstab, etc.

上面的命令会创建一个/device/samsung/i9300/文件夹,在你的Cyanogenmod源代码repo结构里。这个文件夹里面有AndroidBoard.mkAndroidProducts.mk,BoardConfig.mk cm.mk,device_[codename].mk,kernel (二进制的) recovery.fstab等等文件。

This will not build the kernel/ directory. You will need to do that later, when you are ready to build the kernel.



If it returns the message "unpackbootimg not found. Is your android build environment set up and have the host tools been built?" please be sure that you run the following command during setting up the developer environment:

$ make -j4 otatools



Method 2: Fork a similar device's git repository


If you've got a GitHub account, you might want to start by forking another, similar device, and then rename it for your device. See the section on setting up github for a discussion on how to name your repository.

如果你有一个git账号,你可能想通过复制另一个相似的设备的文件夹然后重命名为你的设备来开始。可以看看这个section on setting up github关于怎样命名你的仓库的讨论。

Always be sure you're compliant with the license of any repository you fork.


Method 3: create the directories and files manually


You can always start with an empty directory and start creating the files by hand. This is the least recommended and perhaps the most tedious method, but it may be the most instructive. You can look at other devices for reference on what files you need.


Customize the files


There are many files in the device/ folders. We will start by focusing on four files BoardConfig.mkdevice_[codename].mkcm.mkrecovery.fstab, and kernel to get recovery working for your device.

device文件夹里有很多文件。我们会通过致力于四个文件BoardConfig.mkdevice_[codename].mk cm.mk recovery.fstab来开始,kernel文件是为了得到recovery为你的设备工作。

Helpful Tip– Start with the recovery!

The first major step is to get a working recovery image for your device so that testing subsequent update.zips is easy. A working recovery will also assist you in doing backups if necessary.

Since having a working recovery is so critical for doing your port, these next steps will focus more on getting a working recovery than getting CM itself to work. Once the recovery is built and operating safely, the work you've done will apply directly to the CM part as well.




Lets examine each of these files:



This file contains vital architectual and build information about the architecture of your device's motherboard, CPU, and other hardware. Getting this file right is essential.


To get a basic recovery booting, a few parameters need to be set in this file.


The following parameters must be set properly in BoardConfig to compile a working recovery image:


·         TARGET_ARCH: this is the architecture of the device it is usually something like arm or omap3.

·         这是这个设备的架构,通常像armomap3.

·         BOARD_KERNEL_CMDLINE: not all devices pass boot parameters however if your device does this must be filled out properly in order to boot successfully. You can find this information in the ramdisk.img. (You can learn more about configuring the integrated kernel build-from-source here.)

·         不是所有的设备都传递开机参数。但是如果你的设备确实这样,那为了正确地开机这个参数必须被合适地填写。

·         BOARD_KERNEL_PAGESIZE: the pagesize of the stock boot.img and must be set properly in order to boot. Typical values for this are 2048 and 4096 and this information can be extracted from the stock kernel.

·         这是boot.img的页大小。为了开机必须被合适地设置。典型的值是2048或者4096,而且这个信息可以从原来的内核中提取。

·         BOARD_BOOTIMAGE_PARTITION_SIZE: the number of bytes allocated to the kernel image partition.

·         分配给内核镜像分区的字节数。

·         BOARD_RECOVERYIMAGE_PARTITION_SIZE: the number of bytes allocated to the recovery image partition.

·         分配给recovery分区的字节数

·         BOARD_SYSTEMIMAGE_PARTITION_SIZE: the number of bytes allocated to the Android system filesystem partition.

·         分配给安卓system文件系统的字节数。

·         BOARD_USERDATAIMAGE_PARTITION_SIZE: the number of bytes allocated to the Android data filesystem partition.

·         分配给安卓data文件系统分区的字节数


The above information can be obtained by multiplying the size from /proc/partitions or /proc/mtd by the block size, typically 1024.


这上面的信息可以通过把来自/proc/partitions  /proc/mtd的大小和块大小相乘得到,典型的是1024

·         BOARD_HAS_NO_SELECT_BUTTON: (optional), use this if your device needs to use its Power button to confirm selections in recovery.

·         (可选的),如果你的设备需要在recovery中用电源键去确认选择,你要使用这个

·         BOARD_FORCE_RAMDISK_ADDRESS / BOARD_MKBOOTIMG_ARGS: (optional), use these to force a specific address for the ramdisk. This is usually needed on larger partitions in order for the ramdisk to be loaded properly where it's expected to exist. This value can be obtained from the stock kernel. The former is deprecated as of Android 4.2.x and the latter will now be used in 4.2.x and beyond.

·         (可选的)用这个去强制为内存盘指定一个特定的地址。这通常在分区很大的时候被需要。为了让内存盘在它应该在的地方被合适地载入。这个值能从原来的内核得到。安卓4.2.x之前是不推荐的,但之后版本这个东西被使用。


The device_codename.mk makefile contains instructions about which Android packages to build , and where to copy specific files and packages, or specific properties to set during your compilation .


This file can be used to copy vital files into the ramdisk at compilation time.


·         PRODUCT_COPY_FILES: used to copy files during compilation into the ramdisk, which will be located at $OUT/recovery/root.

·        这个变量被使用在编译的时候把一些文件复制到内存盘,这些文件将会位于$OUT/recovery/root。



This will copy the file offmode_charging binary into the sbin folder within the ramdisk.


·         PRODUCT_NAME / PRODUCT_DEVICE: used for setting the value of your codename. This is the name of the device you load with Lunch.

·         被用来设置你的开发代号的值。这是你用lunch载入的设备的名称。


This is simply the prebuilt kernel image or a kernel you built yourself used to boot the device. The format of the kernel may be in a zImage or uImage , depending on the requirements of the architecture of your device.



You'll need to make a few changes to this file to integrate with the lunch , brunch , and breakfast commands, so that your device shows up on the list and builds properly. You'll also set some variables (see other devices) to indicate what size splash animation should be used, whether this is a tablet or phone, etc.


Some of these settings aren't used for building just the recovery, but you may as well set them now because once recovery is done and working, the settings here will be important.


Again, take a look at a similar device to yours to get an idea of what the settings here should be. It's fairly intuitive.



recovery.fstab defines the file system mount point , file system type , and block device for each of the partitions in your device. It works almost exactly like/etc/fstab in a standard Linux operating system.



/system           ext4        /dev/block/mmcblk0p32

This sets the block device at mmcblk0p32 to be mounted on /system as filesystem type ext4


All mountpoints should exist in this file and it is crucial this information be correct or else very bad things can happen, such as a recovery flash writing to the wrong location.



The filesystem type datamedia can be used for internal sdcards as well as setting the block device to /dev/null.



vendorsetup.sh is called when setupenv.sh is run. It is used to add non-standard lunch combos to the lunch menu.


To add your device to the lunch menu:


add_lunch_combo cm_-userdebug

Then build a test recovery image


To build only the recovery, set up lunch as with a regular build, and say make recoveryimage.

为了只编译一个recovery,用一个一般的构建来建立lunch然后输入make recoveryimage

If things break (and they will break), have a look at these tips for dealing with build errors.


Helpful Tip

If you have fastboot, you can try it to install the recovery image to the recovery partition . There are other methods for installing the recovery, such as using dd from a rooted system to flash it into place.



Not much needs to be said here, but make sure the recovery is working before you move on to getting CyanogenMod working. A 100%-working and reliable recovery mode is absolutely necessary before you start testing experimental Android builds.


Adjust recovery_ui.cpp if necessary


You may discover that although the recovery image runs, some of the hardware buttons, such as the volume buttons or power buttons, which would normally be used to scroll through the options, don't work.


You may need to adjust the GPIO values to get the buttons to be recognized. Similarly, you may wish to include/exclude options or modify other UI elements.

你可能需要调整GPIOGeneral Purpose Input Output (通用输入/输出)简称为GPIO,译者注)的值来让按键被识别。同样地,你可能会希望包括或去除一些选项或修改其他UI元素。

To do this, you may wish to create and edit the /device/[vendor]/[codename]/recovery/recovery_ui.cpp. You can find ample examples of this file, the associatedrecovery/Android.mk file that builds it, and how it is used.


Helpful Tip

The GPIO values for your device may be found in the kernel source .



Put your device folder in github, and use a local manifest to automatically sync it with repo sync

把你的设备文件夹放到git上去,用repo sync命令,使用一个本地清单来自动同步它

Once you've started your device folder, create your own GitHub account and set up your folder as a public GitHub repository. This is a great opportunity to learn about git, and also your source can be accessible to others who can collaborate with you.

一旦你建立你的设备文件夹,你就应该创建你自己的GitHub账户并且建立你的文件夹作为一个公共的GitHub仓库。这是学习git 的一个很好的机会,而且你的源代码也可以被那些能协助你的人获得。

When naming your repository, use the format android_device_VENDOR_CODENAME, where VENDOR and CODENAME use the new device's values. So, let's say your GitHub account name is "fat-tire" and your device codename is "encore", manufactured by Barnes and Noble. You should call your repository android_device_bn_encore. It would be accessible at https://github.com/fat-tire/android_device_bn_encore. Similarly, the kernel repository would be called android_kernel_bn_encore. It would be accessible at https://github.com/fat-tire/android_kernel_bn_encore.

在命名你的仓库的时候,使用这样的格式android_device_VENDOR_CODENAMEvendorcodename用新设备的值。所以,假如说你的GitHub账户名是fat-tire而且你的设备开发代号是encore,被Barnes and Noble制造。你应该把你的仓库叫做android_device_bn_encore。这个可以在https://github.com/fat-tire/android_device_bn_encore获得。类似的,内核仓库将会被叫做android_kernel_bn_encore。这个也可以在https://github.com/fat-tire/android_kernel_bn_encore获得。

The last thing to do is create a local manifest for other people to use to automatically download and their keep up-to-date with your changes. Here's an example, using the above scenario:





The revision attribute is optional. If it is omitted, repo sync will use the revision specified by the  tag in the default manifest.


这个revision属性是可选的。如果它被省略,repo sync会用在默认manifest标记的revision

Once you've tested that the local manifest file works, you can pass it on to others, who can then try out your work. At that point you can continue to push your changes to GitHub, and even give other users commit access so that you can work on the device together.


Helpful Tip– Using other repositories

If you find that for some reason you need to replace or supplement other repositories provided by CyanogenMod, you can add additional repositories using the local manifest. Once you've got everything working, you can use Gerrit to submit stuff found in those repositories back upstream to CyanogenMod.



Add the blobs to the vendor/ directory


Once you have a working recovery, it's now time to get CyanogenMod building and working.


The first thing you may do is to get all the proprietary, binary blob into the vendor/ folder, along with a .mk file that will include them in the final build.


This requires three steps:


1.    Create extract-files.sh and setup-makefiles.sh script s to pull those blob files from the device using adb and put them in the right /vendor/ directory. There are plenty of examples available for other devices.


2.    Create an .mk Makefile to copy those files to the $OUT folder during the build process and put them in the right place. Again, use other devices as a guide for what this Makefile should look like. An example filename might be BoardConfigVendor.mk


3.    Make sure that the Makefile you just created is included from your main BoardConfig.mk via a command such as -include vendor/[vendor]/[codename]/BoardConfigVendor.mk. Again, existing devices can illustrate how this is done.

保证你刚刚创建的makefile文件被你的主要的BoardConfig.mk包含,用一个像-include vendor/[vendor]/[codename]/BoardConfigVendor.mk这样的命令。再一次说,存在的设备可以说明这个是怎么工作的。

An alternative is use the blob-free and free code Replicant.


Now revise the device/ directory


Since you have a working recovery, go back and start modifying the files in the device/ folder . As always, use other similar devices as a reference.


You now have a easy means to do backups and test your builds. So start tweaking the device folder itself, and see if you get it to boot… Once you do, from there its a matter of building and supporting the various parts and peripherals, one-by-one.


Getting help from the manufacturers & vendors


Many of the OEM s (Original Equipment Manufacturer s) who make the underlying platform used by your device frequently provide wikis, documentation, and sample code that can assist you in completing your port. You'll find that some companies are more friendly to the development community than others. Here are some of the more common OEMs and vendors, along with web sites and repositories that may help.


(This list is incomplete. Please help add to it)







Google's Git Repository Nexus binary blobs



Dev Center



HP Open Source



Lenovo Smartphones (Search your   device)



LG Open Source Code Distribution



Motorola Open   Source Center



Tegra's GitWeb



Code Aurora   Forum



Samsung Open   Source Release Center

Texas Instruments


www.omapzoom.com , Omappedia

Sometimes if you have questions you can even reach out to the developers via email or the support forums.


Adding XML Overlays


It's very likely in your device_[codename].mk file, there's a line that looks like this:




What this does is set the overlay/ folder to allow you to override any XML file used by Android framework s or apps, just for this device. To do so, create a directory structure which mirrors the path leading to an XML file, starting from the root of your source. Then replace the file you want to overlay.


Example: Let's say you want to override some standard Android settings. Look at the file in frameworks/base/core/res/res/values/config.xml. Then copy it todevice/[vendor]/[codename]/overlay/frameworks/base/core/res/res/values/config.xml. Now YOUR version will be used instead of the other one. You only need to include the settings you wish to override– not all of them, so you can pare down the file to those few that change from the default.


You can overlay any XML file, affecting layouts, settings, preferences, translations, and more.


Make the kernel and kernel modules build from source


If you have previously used a pre-built kernel, you may at some point want to start building the kernel from scratch.


See the instructions for how to change the BoardConfig.mk file to make CyanogenMod build the kernel and any required kernel modules automatically.




There's no way a single wiki page will tell you everything you need to know to do a port from beginning to end. However, hopefully you now have an understanding of how things are set up and the steps you need to take. You can always ask for help on the CM forums or on IRC. Others with the same device, chipset or platform (i.e. same ARM chip) may jump in to help too.


Hopefully you'll find the process rewarding and educational. And it'll get you some street cred as well.


When you're all done, and your port works better than stock… when it's stable and shiny and marvelous and wonderful and includes improvements, free code or commons grounds for different devices…


You may want to contribute your work upstream. Here are the instructions for how to do just that.


Good luck!


See Also

·         Android Stack

·         ARM

·         buildinfo.sh

·         CyanogenMod Installer, for official release installation.

·         CM source

·         Development

·         Submitting A Port

·         Unofficial Ports, to install unofficial ports.

·         VirtualBox

External links

·         Android-Porting — the official Google Group on this topic

·         General CyanogenMod Porting Discussion — a forum post on porting

·         How To Port Different Roms to Your Device

·         How to port ROMS.


·         Porting