Tired of the standard official firmware and want to surprise your friends with something unusual on your smartphone? Or, perhaps, as a user, you don't quite like the result of using custom versions? Find out how to make a firmware on Android yourself and customize it for yourself.
Preparing your computer
First, it is advisable to make sure that the computer system is configured properly. The optimal requirements for it are as follows:
- Linux OS (ideally should be UBUNTU);
- Android 2.3 and higher requires a 64-bit system;
- the minimum amount of free space is 10 GB, and ideally 15 GB (this is necessary for storing the sources and further changes with them).
If these requirements are met, you need to start installing packages (for example, Cyanogenmod 9):
- We pass authorization in UBUNTU.
- We launch the terminal.
- Install the Java programming language.
- Install packages in the terminal.
- On the computer, create folders: mkdir -p ~ / bin (register in the same way) and mkdir -p ~ / android / *** (instead of ***, you can write any name in Latin).
- Install the repository server where we will upload the sources.
- We overload the PC.
- First, go to the folder that was created earlier to store them: cd ~ / android / *** /.
- Download the sources.
After that, you need to wait for the download to complete, this will take several hours. Moreover, in the case when there was a network break or any other error, you can re-drive the repo sync -j16 command, after which the process will recover from the point of the break.
Assembly
Consider a situation in which cyanogenmod is officially supported by the device. In this case, the steps are as follows:
- Although the firmware is a complete "zero" at the very beginning, some libraries will not be able to be flashed. the developers did not supply the source code. Therefore, to copy proprietary files (which are someone's property), you need to connect the gadget to the computer using a cable and write the command cd ~ / android / system / device / brand / model / ./extract-files.sh in the terminal.
- Now you should load RomManager (this software is loaded assembled), for which you need to register ~ / android / system / vendor / cm / get-prebuilts.
- After that, only the process itself remains:. build / envsetup.sh && brunch model.
In the event that cyanogenmod is not supported at the official level, the first step is to create a "file tree", and then perform the above steps.
Modifying an already prepared file
Base selection
To create your own firmware from a ready-made one, you must first find it. To do this, you need to find a file on the network, the name of which will indicate that the firmware is clean (for example, "Pure Android 3.0 ROM"). It can be anything, but in this case it will be necessary to undo the changes made by the author.
After the file is downloaded, you need to unpack it.
Firmware structure
All those folders and files in them that the user will see after unpacking are components of the operating system. Their composition and order depends on what the author wanted to get in the end. In this case, in any case, among all the components 3, it will be necessary:
- meta-inf - all information about the firmware, which includes certificates, checksums and scripts;
- boot.img - boot image;
- system folder - OS without a kernel with preinstalled applications, configuration files, and more.
Installing the software
To change an existing set of programs, you need to go to / system / app. And now you can do the following in it:
- just delete the folder with the unnecessary program;
- insert the required software;
- install Linux system applications such as Midnight Commander, which will need to be unpacked first.
Visualization
But the most common reason a user wants to create their own firmware is to change the look of the shell. Graphics settings are stored in a single framework / framework-res.apk file. It needs to be unpacked, after which the folder of the same name will appear, in which you will need 2 subfolders:
- res / drawable- * - graphic elements with resolution.png;
- res / layout- * - graphic elements with .xml resolution.
After the owner of the Android-based device has changed everything that he needed, it remains to collect the graphics file back.
To change the animation when the device boots up, you need to do the following:
- unpack the archive with the files of this animation;
- replace existing images with the ones you need;
- pack back.
Additional settings
When creating your own firmware, you can use the following commands to improve system performance:
- ro.media.enc.jpeg.quality = 100 - the quality of uploaded images in .jpeg format will be increased;
- debug.sf.nobootanimation = 1 - animation will be disabled when the device boots;
- ro.mot.buttonlight.timeout = 0 - after turning on the screen, the control buttons will be highlighted immediately.
These and many other lines are located in system / build.prop.
Build process
After all the manipulations with the future firmware, it needs to be turned back into an archive, for which we write $ cd ~ / rom; zip -r my-rom.zip *.
The next step is to name the archive. Then you need to move it to a flash drive, and turn off the device itself, which is necessary to enter Recovery and upload a new firmware.
But before flashing, you should definitely make a dump (backup) of the firmware that is currently installed on your phone or tablet. This is necessary because in case of an error during creation, you can turn the device into a brick or it may work unstable, and therefore you need to return it to its previous working state.
Android Kitchen
The easiest way is to log into the Android Kitchen website. Here, even a non-professional can create the firmware himself based on the finished file, while gradually choosing certain settings for icons, volume, fonts, screen and much more.
After the choice of changes has been made, the user only needs to select the version of the firmware that is currently being used (it is important not to make a mistake here), check the list again in the “Summary” tab and click on the “Submit Work to Kitchen” button. Now you need to wait for your turn to create an archive with the firmware file, which can then be uploaded via Recovery.
But before flashing, you should definitely make a dump (backup) of the firmware that is currently installed on your phone or tablet. This is necessary because in case of an error during creation, you can turn the device into a brick or it may work unstable, and therefore you need to return it to its previous working state.
Android Kitchen
The easiest way is to log into the Android Kitchen website. Here, even a non-professional can create the firmware himself based on the finished file, while gradually choosing certain settings for icons, volume, fonts, screen and much more.
After the choice of changes has been made, the user only needs to select the version of the firmware that is currently being used (it is important not to make a mistake here), check the list again in the “Summary” tab and click on the “Submit Work to Kitchen” button. Now you need to wait for your turn to create an archive with the firmware file, which can then be uploaded via Recovery.
One of the most popular, if not the most popular operating system for mobile devices, be it smartphones, tablets or other devices, is undoubtedly Android. There are a great many mobile gadgets based on this software, and even more - firmware versions, both official from the manufacturer and unofficial, collected by amateurs or fans of this or that device. But it happens, it happens that this or that firmware does not suit. The reasons can be very different, from performance to interface, and many other small nuances. What to do in this case? Create the firmware yourself!
The firmware of your own device can be redrawn as you like, you can change many elements, animations, icons, speed and energy saving settings, and so on. The scope for imagination is undeniably large, and it is impossible to predict what will seem to be the ideal choice for this or that person. After all, everyone strives to customize everything just for themselves.
Create Android firmware
We will analyze a way to create your own firmware, which is great for not the most experienced users, but who are fully charged with enthusiasm. It is not always necessary to go into low-level programming to achieve the desired changes, very often the desired functions or appearance can be changed much more easily. All you have to do is visit the dedicated Android Kitchen website. It is in this “kitchen” that the process of “cooking” the new version of the software will take place. The only caveat is that you will have to take an existing version created by someone else as the basis for the new firmware, but it will not be difficult to season it with all sorts of improvements, changes and other "spices".
After visiting Android Kitchen, you can choose what needs to be changed - battery indicator, system icons, status bar, various animations, volume change dialog box, dividers and progress bar, lock screen, fonts. Choosing certain functions in the "kitchen", you can immediately, in real time, preview the changes made in order to evaluate them. After all the necessary changes have been made, go to the File Upload tab. Some settings are available here, but by default they are selected optimally - do not change them if you are not sure what you are doing. In the "Select your ROM from Kitchen`s list or upload your own files" section, select the "Kitchen`s list" option. Select the firmware to be used from the drop-down list. Be careful - if you specify the wrong software version, there is a high probability of an error, after which, at best, the patch will not be applied at all, and at worst, the system will stop booting and you will have to completely reflash the device.
It often happens that some of the Android users do not like the standard firmware of their smartphone or tablet. For example, due to excess software, due to which it is rapidly decreasing, or simply do not like the functionality of some programs and want to replace them with others. An intensive search for custom firmware begins, but they do not always give the desired result. What to do?
Any firmware can be modified for a specific user
Not everyone knows that the firmware can be finished to suit your personal needs. There are several ways to do this, each of them differing in the level of complexity and the required set of tools. And, if you don't know how to build Android firmware yourself, this article is for you.
Building from source
One of the most correct ways is to use the source code published by the Google development teams or Cyanogenmod. But at the same time, this method is the most difficult, because in order to build Android firmware from source, optimize it and make it work on a specific device, you need to have rather deep programming skills, to understand all the intricacies of the mobile operating system and device hardware. This knowledge is not acquired in a day, so in this article we will not describe this method in detail.
Modifying an already prepared file
If you are not too versed in all the intricacies of the OS, but want to change something in your firmware, the best solution would be to correct it already. You can change both native, built-in firmware, and already modified by someone else. There are a lot of customized firmwares on the Internet, and you are unlikely to experience a shortage of them. So, we present step-by-step instructions for assembling your own firmware based on an existing product.
Editing with a computer
Required software
We need a computer, a device, a firmware file, and a special program called Android Kitchen (also known as a kitchen). The firmware file can be found on specialized forums, the most famous are the English-speaking XDA Developers and the Russian-speaking w3bsit3-dns.com. In the section of your device model, you can find links to the most popular and tested firmware, both official stock and unofficial custom ones.
Next, you need to install the kitchen on your computer. It works best on Linux, but the required libraries can be installed on Windows as well. In this case, you can get out of the situation by installing Cygwin. and follow the step-by-step instructions included in the archive. Before that, you will also need to install the Java Platform (JDK) from the official website (http://www.oracle.com/technetwork/java/javase/downloads/index.html for Windows) or find and download OpenJDK Java 6 in the Ubuntu Application Center Runtime or similar (for Linux). The second use case is to install Linux on a virtual machine and control the process through it.
Firmware modification
Firmware is most often distributed as a file with the .img extension, less often as a ZIP archive. In both cases, you will need the firmware in the folder of the installed kitchen so that it can import it and start working with it. The kitchen must be installed in the path c: / cygwin / home / user / (when installing via Cygwin) or File system / home / user / (when using Linux).
- Start the kitchen through Cygwin or Linux terminal using the command cd kitchen, then. / Menu.
- Unpack the archive into the kitchen, as mentioned above.
- After the program menu appears, go to section 0. Advanced Options.
- After that, a list of commands for modifying the firmware will be presented. Choose exactly the one you need. You can add Busy Box, Root, Apps2SD, replace stock applications, various animations, free up device memory and much more.
- After finishing the manipulations, run in the main command 99. Build ROM from working folder (Build firmware from working folder) and take the ZIP archive with OUTPUT_ZIP.
Device firmware
You can flash the device both through a computer and without it. In the first case, you need to download the program for the firmware, usually the Flash Tool or Odin, drivers for your device model and prepare an already corrected archive.
When flashing via Recovery, you need to copy the file to the root of the memory card, boot the device in Recovery mode, format the device and cache, and then install the firmware from the archive. After the reboot, you will have the firmware you personally changed.
Editing on a device
The easiest way possible. No additional devices and manipulations are needed. All you need is a rooted device, a backup application (Nandroid backup is best) and a file manager with the ability to change the system partition.
Changing your own firmware
- If the device is not yet rooted, get it. How to do this, you can read on specialized forums in the section dedicated to your particular device. The fact is that they are supported by a small number of devices and most of them have an individual procedure.
- Install Nandroid backup (https://play.google.com/store/apps/details?id=com.h3r3t1c.onnandbup&hl=ru) and use it to back up your device's system. Save it in a safe place, for example, in the cloud storage. Why create a copy? Suddenly something goes wrong or you accidentally delete something you need - there will be an opportunity to return everything as it was.
- Install a file manager that works with the system partition to remove unnecessary software and add your own applications. Titanium Backup is the gold standard.
- Select the apps you want to uninstall and uninstall them through the file manager.
- Install the applications with which you want to replace the deleted ones, and make them system ones through Titanium Backup.
- Reboot your device and enjoy your progress.
Changing third-party firmware in ZIP archive
- Download the firmware file you are interested in in .zip format.
- Install a file manager that can work with archives, for example, ES Explorer or Total Commander, and unpack the contents of the archive.
- Remove unnecessary or add missing applications, then pack the archive back and move it to the root of the flash card.
- Use Nandroid backup (https://play.google.com/store/apps/details?id=com.h3r3t1c.onnandbup&hl=ru) to create a system backup and copy it to a cloud drive.
- Flash the device from Recovery mode.
Conclusion
As you can see, assembling Android firmware with your own hands is not necessarily very time-consuming and requires deep knowledge. It is clear that it will be much more difficult to create a modification from scratch, but almost everyone can tweak or replace and remove unnecessary programs. We hope our instructions helped you with this.
Have you compiled the Android firmware yourself? What did you change in it and how did you do it? It will be interesting if you share your feedback.
Has it ever happened to you that I installed a fresh new custom firmware. And it seems to be just perfect from all sides. Nimble, with the latest version of the system, beautiful to the point of horror. But suddenly a friend boasts that he also renewed himself yesterday, and you understand that someone else's piece is more beautiful, faster, tastier, more desirable. What to do?
The answer is simple - you can take and reshape your firmware as needed. Replace various elements in it, add some of your animations or other things. For example, do you want an animation of waiting, a charge indicator or a progress bar, as in the screenshot, but with the ability to change colors and shapes for yourself? Then under the cut I will tell you how you can do this.
To change your firmware, the first thing you need to do is go to the kitchen website http://uot.dakra.lt/kitchen/. It is there that the whole process will take place. In fact, it will not be possible to assemble the firmware from scratch. You will have to take someone's creation as a basis, but season it with your own spices is easy.
We followed the link, and then everything is simple. We choose what we want to change: battery indicator, system icons and emoticons, status bar, appearance of popups, waiting animation, glow effect when scrolling through lists, volume change dialog, separators in lists, progress bar, lockscreen, animation of transition between windows, fonts, bootanimation, etc.
Moreover, choosing some options in the kitchen, it is possible to create a real-time preview of the changes in order to see what will be the result.
After selecting the changes you need, you need to go to the file upload tab. There, from the settings, you should not change anything unless absolutely necessary. Only in the "Select your rom from kitchen" s list, or upload your own files "section, select the" Kitchen "s list" option. A drop-down list will appear, in which you will need to specify the firmware to be used. If you specify not yours, then there is a high probability that the generated patch will not apply, or even worse - you will have to do a flashing, because the system will not be able to boot.
After all these manipulations, go to the "Summary" tab, check the list of changes that have been planned and press the "Submit Work to kitchen" button.
Then we go to the page http://uot.dakra.lt/pickup/, where we wait for our turn. As soon as it comes, the site will give you a .zip archive with a freshly prepared patch for the firmware, which must be flashed through the recovery.
Attention, do not forget to make a system backup before flashing!
Happy customizations!
If you are interested in the news of the IT world, subscribe to the materials of the site in,.
This inspires us to write new materials. Thanks;)
And just below you can read or leave comments. Scroll the page? Have something to say?
Comments:
Teutonick: And yet, I am skeptical about such things. Looking at how many problems people have with ordinary flashing, sometimes between two stock versions, putting such a Frankinstein to just about anyone, IMHO, is unsafe =) I have never tried it myself ... so I won't say anything specific, just observations
Any Android user has his own idea of how the operating system should look, what functions it should perform and what set of software should be installed in it by default. However, not everyone knows that creating your own firmware is not so difficult. To do this, it is not at all necessary to understand the Linux kernel, be able to compile Android sources or understand how a smartphone works.
Introduction
There are three ways to create your own firmware for an Android communicator: 1. Upgrading and compiling the operating system from sources published by Google or the CyanogenMod team. 2. Modification of the stock firmware of the communicator. 3. Modification of third-party firmware created using the first or second method.
The first method is the most correct and flexible, but it often requires deep knowledge of the features of Android and the ability to edit the source code of the system so that they then work on the device. This topic is beyond the scope of our article, so we will not consider the assembly of Android sources, but we will focus on two other methods, more precisely on the third.
Third-party firmware (so-called mods) exist for almost any Android device that has been on the market at least a week. Usually, they already include all the necessary modifications necessary for the correct operation of the firmware on the communicator, and therefore represent an excellent platform for experimenting with the system. They can be modified almost beyond recognition, include any software in the OS, change its appearance, create many low-level settings using a simple text editor and file manager. These actions do not require deep knowledge of the operating system and can be performed by any reader of the magazine.
Choosing a Subject
So, let's assume that our communicator is already booted up and the ClockworkMod recovery console is written to the boot area, allowing you to install any firmware on the device without any restrictions (we wrote about how to do this in the article "Total Submission" published in the October issue] [ ). Now we want to install a different firmware on the device, but not anyhow, but with our own modifications, settings and a set of software. Therefore, we need a framework, namely someone else's firmware that works stably on our device. Where can I get it?
The main habitat of all romodels is, of course, the xda-developers.com forums. There you can find anything you want for communicators running iOS, Windows Mobile, Windows Phone and Android. Open the site in a browser, click on the Forums section and look for your communicator in the forum lists. Then we go to the corresponding section of Android Development and carefully review the list of topics containing the word "" in the title. Better to find some clean firmware with a name like "Pure Android 2.3 Rom" or a port of CyanogenMod, although, in essence, any other will do (although you may have to undo the copyright changes). Open the topic, skip the first post, find a download link somewhere at the end and load the ROM on your computer.
Now the firmware file needs to be opened. This is done using the most common unzip:
$ mkdir ~ / rom; cd ~ / rom $ unzip ../path/to/firmware.zip
General directory structure and important files
The set of files and directories resulting from the execution of the previous command is, in essence, the Android operating system, and exactly in the form in which it will be located in the device's NAND memory. Depending on the version of Android and the author's imagination, it may contain different sets of directories and files, but it always contains three required objects: META-INF, the boot.img file, and the system directory.
The first directory contains metadata about the firmware, including the author's certificate files, a manifest with a list of files and their checksums, and an update script that can create new files in NAND memory, change access rights and display a progress bar that users see during installing the firmware.
The boot.img file contains a boot image that includes the Linux kernel and initrd image. It can be unpacked, but it is not very useful for us, since almost any system parameters can be changed using the configuration files and the / proc file system. If you need a kernel compiled with special parameters, for example, with an activated BFS scheduler or NFS support, then you can almost certainly find it on the same xda-developers and flash it using ClockworkMod.
Finally, the system directory is what it was all about. The contents of this directory represent the Android operating system without the Linux kernel. It contains everything that is needed for the OS to work, and therefore it is simply necessary to know its structure. It looks like this:
- app- pre-installed applications: phone, calculator, calendar, etc.
- bin-analog for the / bin and / usr / bin directories in Linux. Contains various system components used by higher-level system components. For example, this is where the dalvikvm virtual machine lies.
- etc- settings files. Full analogue of / etc in Linux, used, however, only by system components. Android apps store settings in the / data / data directory.
- fonts- fonts. Contains only Droid (or Roboto in Android 4.0) branded fonts by default.
- framework- sets of Java classes used by the system and Android software. There is also a framework-res.apk file containing a complete description of the operating system interface, including all graphic files.
- lib- Linux libraries used by low-level components of the system. The analogue of the / lib and / usr / lib directories in Linux, includes such standard libraries as libc (although Android uses its own Bionic instead of Glibc), libz (gzip encryption), libssl and others.
- media- media files: ringtones, notification sounds, interface sounds and OS boot animation files.
- tts- files required for the speech synthesizer to work.
- usr- an optional directory that usually contains the files needed for the software to work from the bin directory. Essentially analogous to / usr / share.
- vendor- files supplied by the manufacturer of the device. Usually contains binary firmware for various hardware components, such as a Wi-Fi module.
- xbin- an optional directory that contains everything that is not in bin. As a rule, it is used to store useful utilities, however, not necessary for the system to work (top, text editor). CyanogenMod uses it to store administration tools: bash, ssh, powertop, busybox, etc.
- build.prop- a file containing information about the assembly, as well as various low-level settings.
Setprop command
The build.prop settings given in the article can be applied to an already running system using the setprop command:
# setprop debug.sf.nobootanimation 1
Own set of software
The / system / app directory contains all the software preinstalled in the firmware. By removing and adding packages to this directory, we can change the set of applications available out of the box. For example, it's not a secret for anyone that the standard Android launcher (and ADWLauncher in CyanogenMod) slows down and has numerous drawbacks. OK, let's replace it with LauncherPro:
$ rm system / app / Launcher.apk $ wget goo.gl/U9c54 -o system / app / LauncherPro.apk
And it's all. You don’t need to install anything, you don’t need to poke around, just drop the required application into the directory - and you're done. Even the name doesn't matter, Android will find the application it needs and install it as a home screen. In the same way, you can put any other program in the firmware or remove it from there.
It is useful to put one of the applications for finding a lost smartphone into the firmware (for example, prey), then even if it is reset to factory settings, it will remain in the OS and will work. You can also replace some system software, for example add Dialer One instead of the standard Phone.apk or Go SMS instead of sms.apk.
How about Linux system applications like ssh server or mc? Here, too, everything is simple. You can build software for Android and an ARM processor using the NDK from Google, but most of the necessary applications have already been assembled before us. For example, we want to preinstall mc in our firmware. Go to xda-developers and search for Midnight Commander. On the first page, we find the apk-package with the installer and unpack it using the same unzip:
$ cd / tmp; unzip ~ / NativnuxInstaller_1.1.apk
We see assets / kits / mc-4.7.5.4-arm.tar.jet in the list of unpacked files. This is a tar.gz archive, which is unpacked to the root of the system after installing the apk package (or rather, after installing the apk, running the application and clicking the Install button). We can immediately unpack it into our firmware and get the preinstalled mc:
$ cd ~ / rom $ tar -xzf /tmp/assets/kits/mc-4.7.5.4-arm.tar.jet
Now, to launch the file manager on the device, just open a terminal and type mc. Other applications can be distributed in zip archives for firmware using ClockworkMod Recovery. It's even easier to put them in your mod, for this you just need to go to the root of the firmware (in this case ~ / rom) and unzip the archive using unzip.
External appearance
Custom firmware is most often created in order to change the appearance of Android to your liking. This operation in Android is, again, very simple. All Android GUI settings are stored in the framework / framework-res.apk file. It can be unpacked using the apktool utility:
$ cd ~; wget goo.gl/hxz5l $ tar -xjf apktool1.4.1.tar.bz2 $ cd ~ / rom / system / framework $ java -jar ~ / apktool.jar d framework-res.apk
As a result, the framework-res directory should appear in the current directory, containing all the package files. The most interesting subdirectories within it are res / drawable- * and res / layout- *. The first one contains all the graphic elements in the form of png files for different resolutions and screen positions. For example, drawable-land-mdpi is a directory with graphics resources for medium-resolution screens that are in a horizontal position (when the screen is rotated, the OS switches to using other files). Of course, any file can be edited or replaced with another.
The layout directories contain XML descriptions of graphical elements (they are actually stored in binary AXML format, but apktool converted them to regular XML). The format of the description is quite simple and straightforward, but it's hard to figure it out with a snap, especially if you don't know where everything is. Therefore, we will again turn to the services of the inhabitants of the xda-developers forum, who have already come up with a lot of different modifications for the Android graphical interface. They are easy to find with the search term "framework-res mod device_name".
Usually such mods are distributed in the form of a ready-made framework-res.apk file, which you can simply put into your firmware. If you want to find specific differences in the content, then the mod can be unpacked and compared with your framework-res using diff:
$ diff -R ~ / framework-res \ ~ / rom / system / framework / framework-res
Unfortunately, within the framework of one article, we cannot consider at least part of the internal structure of framework-res, so for more information, refer to the corresponding topic of the w3bsit3-dns.com forum.
After making the modifications, you can build framework-res.apk using the same apktool. However, this operation requires the aapt utility from the Android SDK, which apktool uses to finalize the apk file. It can be obtained separately:
$ cd ~ / bin; wget goo.gl/tC7k8
Now you can build the file:
$ cd ~ / rom / system / framework $ java -jar ~ / apktool.jar b framework-res $ cp framwork-res / dist / framework-res.apk. $ rm -rf framework-res
The next step is to change the loading animation. It is stored in the form of regular png-files packed in the system / media / bootanimation.zip archive. Let's unpack it:
$ cd / tmp $ mkdir bootanimation; cd bootanimation $ unzip ~ / rom / system / media / bootanimation.zip
Inside there is a desc.txt file describing the animation in the following format:
Width Height FPS p Order Pause Directory ...
The standard view of this file is:
480 800 30 p 1 0 part0 p 0 0 part1
This means that the image is 480 x 800 and the frame rate (FPS) is 30 / s. The following is a description of the first part of the animation, the files of which are located in the part0 directory. It is played once (number 1 after p). The next part (part1) is played an infinite number of times until the device boots up. Typically, the part0 directory contains the images corresponding to the first part of the animation, and part0 contains all the other images that are played in the loop. The images themselves must be the same size, and their names must contain numbers in ascending order, for example 0001.png, 0002.png, etc.
Since the loading animation has a very simple format, it is quite easy to make. It is enough to convert the video into png images using mencoder (in desc.txt, you must set the FPS value to 24):
$ mplayer -nosound -vo png: z = 9 video.avi
But this will be superfluous. Participants of the xda-developers forum have done so many animations that the need for manual work disappears altogether. Links to interesting animations are given at the end of the article.
Low-level settings
The last thing I would like to talk about in the article is editing low-level settings. In Android, there is a system / build.prop file for this, which stores information about the firmware assembly and settings for specific devices. By adding certain lines to this file, you can change the functioning of Android, speed up its work, or reduce battery consumption. Below are the most interesting settings.
- Prevent unloading the desktop from memory: ro.HOME_APP_ADJ = 1
The option allows you to make the work with the device more convenient due to instant access to the desktop at any time. Not recommended for low memory devices.
- Improving the quality of saved JPG files: ro.media.enc.jpeg.quality = 100
Allows you to sharpen camera shots, but significantly increases the load on the CPU.
- Disable boot animation to speed up the loading of the operating system: debug.sf.nobootanimation = 1
- Assigning part of the work on rendering the interface to the GPU: debug.sf.hw = 1
Allows you to make the interface faster and smoother.
- Blocking notification of active debugging mode (when connected to a computer using USB): persist.adb.notify = 0
- Eliminating the problem with a black screen after the call ends: ro.lge.proximity.delay = 25 mot.proximity.delay = 25
- Turning on the backlight of the control keys immediately after turning on the screen: ro.mot.buttonlight.timeout = 0
In addition to all this, many users also recommend using the following flag combinations:
- Reducing touch screen response time: debug.performance.tuning = 1 video.accelerate.hw = 1 windowsmgr.max_events_per_sec = 150
- Increase battery life: wifi.supplicant_scan_interval = 180 pm.sleep_mode = 1 ro.ril.disable.power.collapse = 0
- 3G module tweaks: ro.ril.hsxpa = 2 ro.ril.gprsclass = 10 ro.ril.hep = 1 ro.ril.enable.dtm = 1 ro.ril.hsdpa.category = 10 ro.ril.enable. a53 = 1 ro.ril.enable.3g.prefix = 1 ro.ril.htcmaskw1.bitmask = 4294967295 ro.ril.htcmaskw1 = 14449 ro.ril.hsupa.category = 5
- Improving network performance: net.tcp.buffersize.default = 4096,87380,256960,4096,16384,256960 net.tcp.buffersize.wifi = 4096,87380,256960,4096,16384,256960 net.tcp.buffersize.umts = 4096,87380,256960,4096,16384,256960 net.tcp.buffersize.gprs = 4096,87380,256960,4096,16384,256960 net.tcp.buffersize.edge = 4096,87380,256960,4096,16384,256960
All these lines just need to be placed in the system / build.prop file and saved.
Assembly
OK, we made the necessary changes, implemented our applications, tweaked the system and now we need to create an OS image ready for firmware. The testsign utility will help us with this. First, you should zip the firmware:
$ cd ~ / rom; zip -r my-rom.zip *
Now you need to sign the archive so that Recovery can install it:
$ wget goo.gl/OyBBk $ java -classpath testsign.jar testsign \ my-rom.zip my-rom-signed.zip
After that, upload the my-rom-signed.zip archive to the device's memory card and turn off the device. To get into Recovery, turn on the device while holding down the volume down key (for some devices, the procedure may be different).
Now go to the "Install zip from sdcard" item, and then to "Choose zip from sdcard", find my-rom-sign.zip on the SD card and select Yes. After the installation is complete, select "Reboot system now".
conclusions
Android is a flexible platform, and this article does not cover all the possibilities for its modification. Deeper modifications can include replacing the kernel, changing the lock screen and standard applications, activating features such as automatically installing applications to a memory card, implementing a boot script mechanism (/etc/init.d), and much more. We will talk about all this in the following articles.
Experienced users are often looking for how to make the firmware of a device on Android themselves. One of the key features of this operating system is that it comes open source. It includes the core, user interface, libraries, and core applications, all available for free.
What is custom firmware
Data-lazy-type = "image" data-src = "http://androidkak.ru/wp-content/uploads/2017/06/protech1-e1498230690613.jpg" alt = "(! LANG: android tablet with tools" width="267" height="200">
!}
Any user with the necessary technical skills can build their operating systems using Android source code and install them on smartphones. Thanks to such opportunities, many non-commercial projects have already been created, the participants of which are developing alternative distributions. Usually they are called "custom firmware", however, a more accurate definition in this case can be considered as "homemade firmware".
Despite the fact that all the necessary materials are available to users, many believe that creating their own ROM is an overwhelming task. Success in this business will depend on perseverance and how much time a person is willing to devote to creation.
In order to install custom firmware on Android, you need to assess the scale of the task ahead. If you have absolutely no coding experience, command line skills (on Linux or Mac), and have no idea what a Makefile is, then it’s better to ditch the idea.
Android is a complete operating system. It is quite complex and contains many different subsystems. Building an OS is rewarding, but also very complex. Any changes you want to make to the stock operating system will require careful consideration. It will take dedication and many hours of hard work to create an alternative distribution that is radically different from its predecessor. If the user has already had to deal with writing program code and he has an idea of what a Makefile and compilers are, then creating his own version of the OS can be successful.
Read also: How to update the version of Android on a tablet
In theory, one could create custom firmware for any computing device capable of running a modern operating system. But it's best to limit yourself to creating a software environment for devices that fit perfectly with stock systems. The Nexus 5X smartphone will be used as an example.
What is needed to create the firmware
Data-lazy-type = "image" data-src = "http://androidkak.ru/wp-content/uploads/2017/06/linux-i-mac-e1498231546463.png" alt = "(! LANG: linux and mac" width="300" height="171">
!}
You will need access to a Linux or Mac computer to create the firmware. In both cases, the PC will be used frequently, so you need to be sure that the software environment you are using is working.
If you create your own assembly using a Linux virtual machine, then with a high degree of probability it will not be able to recognize the mobile device and will refuse to work with it. If you don't have a full-fledged Linux operating system at hand, then it's better to turn to a Mac computer.
In order to create your own firmware, you will need 130 GB of disk space and at least 8 GB of RAM. If you try to do this with 4GB of RAM, you can get a lot of problems. Similar difficulties can arise with 8GB of RAM, but some tricks can be overcome.
You need to be patient as building an Android build is a long process. It can take over 24 hours to sync the original repository with the local machine. It will take a few more hours to complete the build. Even after making minor changes, it can take 10–20 minutes for them to be accepted. Much will depend on the hardware, but do not expect a powerful system to complete all processes in a few minutes.
The version of the operating system, dubbed the Android Open Source Project, does not contain the usual Google services. As a result, apps like Google Play, YouTube, Gmail and Chrome will be missing. Fortunately, there is already a way that can make these programs work on custom firmware.
The process of creating an assembly is to download the Android Open Source Project and make changes to its source code. Google provides excellent documentation for users on how to create an AOSP. It is recommended that you read this manual carefully. A common mistake many users make is that they refuse to read the entire documentation, limiting themselves to just a few chapters that seem to be the most informative.
Process of creation
According to the instructions, you need to take the following steps one by one:
- Set up a software build environment, including installing the required development tools and Java Development Kit.
- Checkout the source using the Repo tool.
- Get your own binaries (some of the drivers are only released in binary form).
- Select a target with the Lunch tool.
- Run build using Make and Jack.
- Install the firmware on the device using ADB and Fastboot.
Many owners of smartphones and tablet computers at some point think about how to flash an android. The need to flash the device may arise due to problems in the operation of the gadget. It also makes sense to update the android in other cases, for example, to improve the functionality of the operating system and.
What you need to do before reflashing android
The wrong approach to the issue of flashing can lead to serious problems with the device, and therefore you need to prepare for this event. Before flashing an android, it is imperative to do the following:
- Make sure your device is fully charged before you start updating your operating system. It is important to eliminate the likelihood of disconnection. You can connect the gadget to the charger during the procedure. If the tablet or smartphone turns off during the firmware update, system and data loss will occur.
- Check the version of the android operating system that is relevant for your device, as well as find out what firmware is currently installed. You can clarify this information in the device settings in the "About phone" section. Pay attention to the android version, kernel version and build number.
- Now, based on these data, you need to find and download a new firmware that will fully match your smartphone or tablet model.
How to flash Android using a computer
It should be said that there are several ways to flash Android and in this article we will look at the most common ones. Let's start by flashing the gadget using a special program that is pre-installed on the computer. There are many applications that allow you to install a new version of the OS on your device, but we decided to stick with the Fastboot program, since it is safe, convenient and reliable, and also best suited for the model that we will be flashing as an example. So, let's figure out how to reflash Android using the Fastboot booster.
Note: the program for flashing Android should be chosen based on which manufacturer's device you are using. We recommend that you familiarize yourself with the following list of programs by manufacturer:
- Samsung - Odin
- Lenovo - Flash Tool
- HTC - Fastboot
- LG - KDZ Updater
- Sony - Flashboot
- Nexus - Fastboot.
First of all, you need to download this application. There will be no problems with the search for Fastboot, it is enough to be able to use search engines, and today everyone can do it. Download the program and unpack it to the root of the C drive so that the file path looks like this: C: \ Android.
The "Tools" folder contains the necessary utilities, and the "Driver" directory contains the drivers. Now you need to connect to the computer the device that you plan to reflash and install the driver. As a rule, the device automatically finds the necessary drivers, but sometimes this does not happen. In this case, you need to open the website of the manufacturer of your smartphone or tablet and download the software. Please note that the firmware that you plan to download is suitable for your gadget model. The firmware must be downloaded in .zip format and placed in the Tools folder, which is located here: C: \ Android.
Before you can flash an android, you need to unlock the bootloader on your device. The bootloader unlocking process will differ depending on the specific gadget model. Open the Start menu on your computer, type cmd in the search bar, and select cmd.exe.
In the Command Prompt window, enter cd C: \ Android \ Tools. Confirm the command by pressing the Enter key, after which you will find yourself in the "Tools" directory.
Now you need to enter a command command that looks like this: fastboot devices.
If you were given a device code, then fastboot detected your smartphone or tablet and you can start flashing the android. If the window says "waiting for device", you need to turn off the gadget and install the drivers. Now you need to enter the command for the firmware: fastboot update firmware_file_name.zip After that, the flashing will start. Remember to reboot your device after finishing the operating system update.
How to reflash android via recovery
Another way to reflash Android is to use standard recovery or custom ones (TWRP \ CWM). What are custom recovery we will explain in more detail below. In short, these are unofficial firmware. So, find the firmware that suits you on the Internet, download it and save it to the root of the file system of your device.
Reboot your device into recovery mode. The process for entering this mode may differ depending on the specific tablet or smartphone model. This is most often done by a combination of the power buttons and the Volume Down key. After entering the recovery mode using the "up" and "down" keys, you need to open the section for installing firmware and patches and specify the file of the firmware previously downloaded from the Internet. As a rule, this item has the following name: "apply update from externel storage", in TWRP - Install ZIP, in CWM - "apply update from sdcard".
Following the instructions above, you will start the flashing, after which you need to reboot the gadget and reset the factory settings. To return to factory settings, go to the settings of your device and go to the "Privacy" section, then click on "Reset settings". After that, you can check the functionality of the newly installed firmware.
How to flash Android via ROM Manager
ROM Manager is designed to perform various tasks, for example, using this application you can create a system backup. By the way, we strongly recommend that you perform this procedure before flashing in order to recover data later. Also ROM Manager can be used to flash android.
ROM Manager will not work if you are not rooted. Such rights can be obtained using special programs, for example, the following applications are perfect: Kingo Android ROOT, Unlock Root, Framaroot or Vroot (detailed instructions here). In addition, a custom recovery should be installed. By the way, in fact, using the ROM Manager, you flash the device through recovery, but unlike the previous version, this one involves working with a much more convenient and intuitive interface.
So, we find and download the ROM Manager program. Now you need to download the appropriate firmware for your device. Open the ROM Manager utility and follow these steps:
1. Place the .zip archive of the firmware in the memory of your Android gadget.
2. In the ROM Manager menu, open the "Install ROM from SD card" section.
3. Find the archive with the firmware and click on it.
4. Next, select the "Reboot and Install" item. In order to be able to restore the operating system in the future if such a need arises, you need to check the box next to "Save current ROM".
5. In the next window, click "OK", after which the smartphone or tablet will go into Recovery mode and the device will start flashing.
What is custom Android firmware?
Firmware of unofficial versions is called custom, that is, created from scratch, or modified. To install them, the procedure for obtaining is not always mandatory. As you already understood, such firmware has nothing to do with official developers, but is created by enthusiasts in order to improve the OS by adding additional features to it and removing errors. At first glance, it may seem that custom firmwares offer solid advantages and are superior in everything to the official versions. However, not all so simple.
The fact is that often such firmwares are not stable and can lead to problems with the device. That is why, before flashing an android using custom firmware, you need to study the reviews of those who have already done this. Only after a detailed study can you download the firmware and start installing it. As for the installation of unofficial firmware, the above options are fine. In addition, detailed instructions for installing custom firmware are almost always available on the site where this very firmware is located.
It should also be said that an unofficial flashing android suggests some differences depending on the specific developer, therefore, the approach to firmware will be different. If you plan to use a special application for flashing the device, we recommend that you familiarize yourself with the following list of programs by manufacturer:
- Samsung - Odin
- Lenovo - Flash Tool
- HTC - Fastboot
- LG - KDZ Updater
- Sony - Flashboot
- Nexus - Fastboot.
This concludes this article. We hope you now know how to flash an android. If you still have questions, ask them in the comments or in the section “ask a question to a specialist”.
I think almost every Android smartphone user had a desire to create (edit) the firmware to suit his needs and desires.
So in this article we will consider the principle of editing firmware for CWM (in zip format)
---
what and how:
Opening the firmware archive you see the following:
META-INF- the folder contains scripts for installing the firmware
system- folder with all firmware files (applications, tweaks, scripts, etc.)
boot.img- the core of the system
Almost all manipulations are carried out in the folder system
its structure:
app- system applications
bin- resources of the system itself
etc- Scripts, tweaks, configs, profiles and system settings
fonts- System fonts
framework- the main files of the system are stored here (graphics, animation text settings, etc.)
lib- system libraries
media- multimedia files (notification ringtones, loading animation, wallpapers, etc.)
usr- settings that are not changed in the future by the system (work in the "read-only" mode)
xbin- again, system configs and other tweaks
build.prop- infa about the system, locale and system performance settings.
---
Applications
Before adding / removing software to the system, you need to check if your firmware is deodexed (that is, check for the presence of .odex files in the app folder. If they are available, then you need to get rid of them using.
-Adding software to the firmware:
First of all, you need to install in your smart those programs that you want to add to the assembly.
After installation, we get them out of the system using Root Exporer and its analogs, they are along the way data / app, we also need them or (if they exist, of course) they are located on the data / data path. They are located in the folder with the same name and have the extension .so .
Then we put the seized .apk files in the archive along the path system / app and files with the extension .so (lib "s) along the path system / lib.
-Remove software from the firmware:
Everything is simple here, go to the folder app- we decide what we don’t need and remove all unnecessary software (it’s better not to touch the system)
---
Language and firmware version
Copy the build.prop file to your desktop. We open it with a notebook and find the lines
ro.product.locale.language = en
ro.product.locale.region = US
for the Russian language, you need to do this:
ro.product.locale.language = ru
ro.product.locale.region = RU
enter the name of your mod into the line
in the same build.prop
---
graphics
The entire graphical part of the firmware is stored in two files
framework-res.apk systemframework file path and SystemUI.apk along the systemapp path. And the graphical part of the settings application is stored naturally in the Settings.apk application.
The principles of unpacking, editing and assembling files with the .apk extension can be studied.
---
Scripts and tweaks (speeding up and optimizing the system)
Most of the settings are made in the file build.prop, about this there is.
Also, if your kernel supports init.d (you can find out about this on the forum about your device) there are a number of scripts for optimizing the system, one of them is described in this article.
---
Replacing system fonts
As stated above, all fonts are contained in the folder fonts, the main fonts are: DroidSans.ttf and DroidSans-Bold.ttf, they can be replaced with any fonts from our site by renaming them similarly to the above and moving them to the archive with the firmware in the folder fonts.
