转载来自:
1,https://sourceforge.net/p/android-x86/wiki/Downloading%20and%20Building/
2,https://sourceforge.net/p/android-x86/wiki/Installation/
Download and Buildnig
Introduction
This page has (hopefully) the latest information about how to build Android for x86 platforms . The built images runs well on a real hardware as well as virtual machines (qemu or virtual-box or vmware-workstation).
Now it is very easy to compile Android for x86 platform from our girepositories. You need not to apply any patch. Just follow the below instructions.
Establishing a Build Environment
Some Requirements
The Android-x86 and Android build is routinely tested in-house on recent versions of Ubuntu LTS (14.04 or 15.10),but most other distributions(fedora ..) should have the required build tools available.
Before you download and build the Android-x86 source code,ensure your system meets the following requirements:
A Linux or Mac OS system(maybe). Certianly it is also possible to build Android-x86 in a virtual machine(not recomend) on a unsupported systems such as Windows. If you are running Linux in a virtual machine,you need at least 16GB of RAM/swap and 100GB or more
of disk space in order to build the Android-x86 tree. See disk size requirements below.
A 64-bit environment is required for Gingerbread (2.3.x) and newer versions,including the master branch. You can compile older versions on 32-bit systems.
At least 100GB of free disk space for a checkout,150GB for a single build,and 200GB or more for multiple builds. If you employ ccache,you will need even more space.
Python 2.6 -- 2.7,which you can download from python.org.
GNU Make 3.81 -- 3.82,which you can download from gnu.org,
JDK 7 to build the master branch of Android in the Android Open Source Project (AOSP); JDK 6 to build Gingerbread through KitKat; JDK 5 for Cupcake through Froyo. See Initializing a Build Environment for installation instructions by operating system.
Git 1.7 or newer. You can find it at git-scm.com.
Choosing a Branch on Android-x86 Tree
Some of the requirements for your build environment are determined by which version of the source code you plan to compile. A listing of branches you may choose as below.
marshmallow-x86
Based on Android 6.0 release (Marshmallow ).
lollipop-x86
Based on Android 5.0 release (Lollipop).
kitkat-x86
Based on Android 4.4 release (KitKat).
jb-x86
Based on Android 4.3 release (Jelly Bean).
ics-x86
Based on Android 4.0 release (Ice Cream Sandwich).
honeycomb-x86
Based on Android 3.2 release (Honeycomb).
gingerbread-x86
Based on Android 2.3 release (Gingerbread).
froyo-x86
Based on Android 2.2 release (Froyo).
eclair-x86
Based on Android 2.1 release (Eclair).
donut-x86
Based on Android 1.6 release (Donut).
cupcake-x86 (aka android-x86-v0.9)
Based on Android 1.5 release (Cupcake).
Once you have selected a branch,follow the appropriate instructions below to set up your build environment. Good luck !!!
Setting up a Linux build environment
These instructions apply to all branches.
The Android-x86 build is routinely tested in house on recent versions of Ubuntu LTS (14.04 or newer version),but most distributions(fedora20 or newer) should have the required build tools available. Reports of successes or failures on other distributions are
welcome.
For gingerbread-x86 or higher versioin, Note a 64-bit environment is required. Older versions can be compiled on 32-bit systems.
NOTEThe complete list of hardware and software requirements see above Some
Requirementssection.
Installing the JDK
The Android Open Source Project (AOSP) requires Java 7 and Android-x86 also require . On Ubuntu,use OpenJDK.
Java 7:
$ sudo apt-get update
$ sudo apt-get install openjdk-7-jdk
If you encounter version errors for Java,set its path as described in the Wrong
Java Version section below.
To develop older versions of Android-x86,download and install the corresponding version of the Java JDK and see Install-Oracle-Java-JDK-on-Ubuntu-Linux.
Java 6: for Gingerbread-x86 through KitKat-x86
Java 5: for Cupcake-x86 through Froyo-x86
Installing required packages (Ubuntu 14.04)
You will need a 64-bit version of Ubuntu. Ubuntu 14.04 is recommended.
$ sudo apt-get install git-core gnupg flex bison gperf build-essential
zip curl zlib1g-dev gcc-multilib g++-multilib libc6-dev-i386
lib32ncurses5-dev x11proto-core-dev libx11-dev lib32z-dev ccache
libgl1-mesa-dev libxml2-utils xsltproc unzip squashfs-tools python-mako
Downloading the Source
Note The source tree you will download include 2 part,the first part is the projects created or modified by android-x86 on our git server and all
the other projects still point to AOSP. some details about projects information can be find in 'default.xml' file .repo/manifests/default.xml.
Now the Android-x86 source tree is located in a Git repository on sourceforge. The Git repository includes metadata for the Android-x86 source,including those related to changes to
the source and the date they were made. This document describes how to download the source tree for a specific Android-x86 branch.
Installing Repo
Repo is a tool that makes it easier to work with Git in the context of Android. For more information about Repo,see the Developingsection
from google websit.
To install Repo:
1. Make sure you have a bin/ directory in your home directory and that it is included in your path:
$ mkdir ~/bin
$ PATH=~/bin:$PATH
Download the Repo tool and ensure that it is executable:
$ curl https://storage.googleapis.com/git-repo-downloads/repo > ~/bin/repo
$ chmod a+x ~/bin/repo
Initializing a Repo client
After installing Repo,create an empty directory to hold your working files,Give it any name you like:
$ mkdir android-x86
$ cd android-x86
Run repo init to download the latest version of Repo with all its most recent bug fixes.
$ repo init -u git://gitscm.sf.net/gitroot/android-x86/manifest -b $branch
For example:
repo init -u git://gitscm.sf.net/gitroot/android-x86/manifest -b marshmallow-x86
Where $branch is any branch name described in the previous section. This will point the projects created or modified by android-x86 to our git server. All the other projects still point to AOSP.
Downloading the Android-x86 Source Tree
To pull down the Android-x86 source tree to your working directory from the repositories,run:
$ repo sync
How to build a image see below.
Building the image
==
The following instructions to build the Android-x86 source tree apply to all branches. The basic sequence of build commands is as follows:
Set up environment
Initialize the environment with the envsetup.sh script. Note that replacing source with . (a single dot) saves a few characters,and the short form is more commonly used in documentation.
$ source build/envsetup.sh
or
$ . build/envsetup.sh`
Choose a target
You need to choose a target for the x86 device you want to use/test. We provides several targets for different branches:
lollipop-x86 / marshmallow-x86
android_x86: for 32-bit x86 platform
android_x86_64: for 64-bit x86_64 platform
jb-x86 / kitkat-x86
android_x86: for x86 platform
honeycomb-x86 / ics-x86
generic_x86: for generic x86 PC/notebook
amd_brazos: for AMD Brazos platform
eeepc: for ASUS EeePC family only
asus_laptop: for some ASUS laptops
tegav2: for Tegatech Tegav2 (may work with other Atom N45x based tablets)
froyo-x86 / gingerbread-x86
generic_x86: for generic x86 PC/notebook
eeepc: for ASUS EeePC family only
asus_laptop: for some ASUS laptops
tegav2: for Tegatech Tegav2 (may work with other Atom N45x based tablets)
sparta: for Dell Inspiron Mini Duo platform
vm: for virtual machine (virtual box,qemu,vmware)
motion_m1400: for Motion M1400 (Intel Centrino M based with Intel PRO/Wireless)
eclair-x86
generic_x86: for generic x86 PC/notebook
eeepc: for ASUS EeePC family only
q1u: for Samsung Q1U
s5: for Viliv S5
donut-x86
eeepc: for ASUS EeePC family
q1u: for Samsung Q1U
s5: for Viliv S5
Actually,for historical reason,you have to use eeepc for a generic x86 PC,notebook or netbook before (includes) donut-x86 branch. Since eclair-x86 branch,eeepc is changed to serve ASUS EeePC family only. Do not use it if you are not using an EeePC.
In short,if you don't know how to choose,use eeepc for donut-x86 branch,and use generic_x86 for eclair-x86 to ics-x86 branches. But note generic_x86 is just a base for other targets. It doesn't have some advanced features like hardware acceleration.
Since jb-x86 we tried to use android_x86 as a universal target for all x86 devices. However,it may not optimized for a particular target device. If you are a developer,you can create a target based on android_x86 for your device.
If you want to add new target for your x86 device,refer to the article.
Using lunch command (recommended)
Now you can select a target by lunch command:
$ lunch $TARGET_PRODUCT-$TARGET_BUILD_VARIANT
where $TARGET_PRODUCT is any target described in the previous section,and possible values of $TARGET_BUILD_VARIANT are eng,user,userdebug. For example:
$ lunch android_x86-userdebug
Then you can build by m command( m command is equivalent to make,but you can use it in any subdirectory of the android-x86 tree.
Note:there are 2 types of images we can build using make (iso_img or efi_img):
$ m -jX iso_img
iso_img: Creates an ISO9660 image,which can be write on cd/dvd medium / USB flashdrive.This is bootable by machines supporting legacy BIOS.
$ m -jX efi_img
efi_img: Creates an image bootable on EFI machines (some new devices like tablets only support this booting method currently)
Since froyo-x86,we also add menu selection to lunch command. Just type lunch,and you will get a list of available targets. Choose a target by inputting its number. Alternatively,just type lunch $number.
Building directly
To build a live cdrom iso image for target android_x86,type:
$ make iso_img TARGET_PRODUCT=android_x86
To generate a live cdrom iso for tegav2,type
$ make iso_img TARGET_PRODUCT=tegav2
Then you will get an iso file out/target/product/x86/android_x86.iso,etc.
If the computer you build on has more then one processor or core,you can take advantage of multiprocessing (or make jobs) by adding -jX to the beginning of your make command:
$ make -jX iso_img TARGET_PRODUCT=android_x86
Replace X by the number of processors you have. For example,if you have a quad core CPU,replace X with 4:
$ make -j4 iso_img TARGET_PRODUCT=android_x86
Using buildspec.mk
You can create a buildspec.mk in your android-x86 directory to remember a particular target product you
build often:
TARGET_PRODUCT:=android_x86
TARGET_BUILD_VARIANT:=userdebug
TARGET_BUILD_TYPE:=release
TARGET_KERNEL_CONFIG:=android-x86_defconfig
With your buildspec.mk file in your android-x86 directory,you can just make by
$ make -jX iso_img
Build smaller image
If you have squashfs-tools 4.0 (older version will not work) installed in your host,the generated Android core filesystem will be compressed by squashfs. So the iso file is very small (only about 30-40%). If you hope to disable it,add USE_SQUASHFS=0 to make.
You can put it to buildspec.mk:
USE_SQUASHFS := 0
Before froyo-x86 (included),If you hope to get a more smaller image,you may remove the debugging symbols by adding
TARGET_STRIP := 1
Since gingerbread-x86,the debugging symbols are stripped by default. Do not use this option anymore.
Testing
The generated image is located at
out/target/product/$TARGET_PRODUCT/$TARGET_PRODUCT.iso
You can easily test the iso file by a virtual box,vmware workstation or qemu.
Of course you can burn the iso to a CD disk and test it on a real hardware. On booting it will automatically detect your hardware and load necessary modules. If you have problem with the default frame buffer driver,you may try the VESA mode (select second
item on boot screen).
Since honeycomb-x86,we supports the hybrid iso format. That is,the iso could be dumped to a usb disk directly. You may create a bootable USB disk by
$ dd if=out/target/product/x86/android_x86.iso of=/dev/sdX
where /dev/sdX is the device name of your USB disk. This feature is only available for iso files released after 2011/12/25. Note usb_img is deprecated.
Do not use it anymore.
Please see Installation page to know details about installation.
Installation
Introduction
Android-x86 includes an option to install to harddisk via easy installer. The supported filesystems are:
ext4
ext3
ext2
ntfs
fat32
You can install Android-x86 to an NTFS filesystem to co-exist with Windows. See the Advanced section below for details.
Step By Step
Burn the iso image to cdrom or you can create a bootble USB stick(recommended- you known it is environmental protection).see the Advanced section below for details.
Boot OS from the Android-x86 installation CD/USB,Choose the 'Install
Android to harddisk' item as show below:
After seconds of booting,you will see a partition selection dialog. You can choose an existing partition to install Android-x86,or you can create or modify partitions by choosing 'Create/Modify
partitions'(here use cfdisk tools). Note you can install Android-x86 to an external disk like USB drive. If the target drive is not shown,try 'Detect
devices'.
Android-x86 can co-exist with other operating system or data in the chosen partition. If the partition is formatted,you may choose 'Do
not format' to keep existing data. Otherwise,choose a filesystem type to format.
Note: The type you chosen must match the partition ID or the boot loader will fail to boot.
Also note if you choose to format to fat32,
you will see a warning that android cannot save data to fat32. You can still proceed to install,but the installed android system will work like a live cd system. That is,all data will lose after power off. But it
has been improved to save data to fat32 or ntfs since 2010. The installer will ask to create a data.img to
save data when fat32 or ntfs is chosen.
Next question is whether to install boot loader Grub. Usually you should answer yes,unless you want to install boot loader by hand yourself. Note the
installer only creates boot items for Android-x86. If you hope to boot other operating systems,you need to add the item to /grub/menu.lst manually.
See the Advanced Section below for how to do this.
If you are lucky,the installation will begin,and you will see the progress bar.
While you see this screen,the installation is complete. Congratulations! Now you can run Andrond-x86 directly,or you can reboot and run it.
Advanced
Create a bootable USB stick for Android-x86
Use the USB image
Download the compressed USB image,uncompress and dump it to a USB stick.
On a Linux host,you can use the command:
*for 64bit*
dd if=out/target/product/x86_64/android_x86_64.iso of=/dev/sdc
*for 32bit*
dd if=out/target/product/x86/android_x86.iso of=/dev/sdc
Note where /dev/sdc is
the device name of the target USB disk. However,some broken BIOS may fail to boot such a USB disk.
On a Windows host,you have sevral choices like Win32DiskImager or USBImageTool ,
and what you want.
Create a bootable USB stick by ISO file
There are some open source tools that can convert an iso into a bootable USB disk:
Linux Live USB Creator ( LiLi ) -- Officially
Support Android-x86
UNetbootin -- see the
demo video. -- Provided Linux/MacOS/Windows
Multi-boot
To boot other operating systems,you have to add boot items for them to /grub/menu.lst. For example,to
boot Windows,add the following:
title Windows`
` rootnoverify (hd0,0)`
`brchainloader +1`
This assumes the Windows is installed to the first partition of the first hard disk. Or you need to change rootnoverify to the appropriate
value. See Grub
Manual for details.
Issues
VMware
When using Android-x86 as a VMware guest OS you must change your virtual disk type to be IDE. The default type in VMware is SCSI,and Android-x86 kernel is not configured to support SCSI.
You can follow these steps:
Create a virtual machine.
Edit virtual machine settings after the virtual machine created.
Choose the hard disk and remove it.
Add a hard disk to create a new virtual disk,then you can choose IDE as your virtual disk type.
When finished,you can install Android-x86 normally.