Creating a Custom TWRP Recovery Without Kernel Source for Chinese Phones: A Comprehensive Guide

The world of custom ROMs and modifications can be an exciting, yet challenging, space, especially when dealing with devices that have limited official support. This is often the case with some Chinese phone models where obtaining the kernel source code required for building a custom recovery such as TWRP (Team Win Recovery Project) can be a major obstacle. However, this doesn’t mean customization is entirely off-limits. In this guide, we’ll explore methods for creating a custom TWRP recovery image even when the kernel source isn’t readily available, leveraging tools like AIK (Android Image Kitchen) and GitHub-based builders.

Understanding the Challenges and Potential Solutions

The primary challenge in building a custom TWRP without kernel source lies in the kernel incompatibility. TWRP requires a kernel compiled specifically for the device it’s intended for. Without the source, we can’t compile a kernel from scratch. However, there are several strategies we can employ:

• Reusing Stock Kernel: We can attempt to repack the existing stock kernel within the TWRP image. This is often the most straightforward approach but can lead to limitations in functionality.
• Using a Similar Kernel: If the device shares hardware similarities with another device for which the kernel source is available, we might be able to adapt that kernel. This requires in-depth knowledge and carries a higher risk of instability.
• Kernel Extraction from Firmware: Some tools and methods allow for extracting the kernel from the phone’s existing firmware, which can then be used for TWRP building.

Essential Tools and Preparations

Before we begin, we’ll need to gather the necessary tools and information.

Gathering the Essentials

• Android Image Kitchen (AIK): This tool allows us to unpack and repack boot images (including recovery images). Download the latest version compatible with your operating system.
• TWRP Builder (GitHub): Several GitHub repositories offer automated TWRP building tools. Some popular options include those by reputable developers, but research for the most suitable and up-to-date one.
• Device Stock Recovery Image: This is crucial. Obtain the stock recovery image for your exact device model and Android version. This will serve as the base for our custom TWRP. You can often find this from firmware packages provided by the manufacturer or on forums dedicated to your device.
• ADB and Fastboot: Ensure you have ADB (Android Debug Bridge) and Fastboot installed and configured on your computer. These are essential for interacting with your device in bootloader mode.
• Text Editor: A good text editor like Notepad++, Sublime Text, or VS Code is necessary for editing configuration files.
• Device Information: Record essential details about your device, including:
  • Model number
  • Android version
  • Bootloader status (locked/unlocked)
  • Kernel architecture (e.g., arm, arm64)
• USB Drivers: Make sure to install the appropriate USB drivers for your phone on your computer so your device can communicate with the computer in Fastboot mode.

Setting Up the Environment

1. Install ADB and Fastboot: Follow the instructions specific to your operating system to install ADB and Fastboot. Make sure they are correctly configured in your system’s PATH environment variable so you can use the commands from any command prompt.
2. Extract AIK: Extract the downloaded AIK archive to a dedicated folder on your computer (e.g., C:\AIK or /opt/AIK).
3. Download Stock Recovery: Place the stock recovery image (usually a .img file) in the same directory as the AIK scripts.
4. Clone TWRP Builder (GitHub): Clone the desired TWRP builder repository from GitHub to a folder on your computer using Git. If you don’t have Git installed, download and install it first.
5. Install Dependencies: Refer to the TWRP builder’s documentation for specific dependencies that need to be installed. This often includes Python packages and other development tools.

Step-by-Step Guide: Building the Custom TWRP

1. Unpacking the Stock Recovery Image

This step involves using AIK to extract the components of the stock recovery image.

1. Open a command prompt or terminal in the AIK directory.

2. Execute the following command:

   unpackimg recovery.img
   

   Replace recovery.img with the actual filename of your stock recovery image.

3. AIK will create several folders, including kernel, ramdisk, and split_img. The ramdisk folder is where the recovery environment’s file system resides.

2. Modifying the Ramdisk

The ramdisk contains the files and scripts that define the TWRP environment. We’ll need to modify it to ensure compatibility and add necessary features.

1. Navigate to the ramdisk folder.

2. default.prop: Edit this file to adjust properties like ro.debuggable=1 and ro.secure=0. Ensure the fingerprint matches your device and firmware version.

3. fstab.[device]: This file defines the mount points for your device’s partitions. This is a critical file. You’ll need to modify it to ensure TWRP can correctly mount the necessary partitions (system, data, cache, etc.).

   • Identify Mount Points: Examine the stock fstab file or your device’s /proc/mounts (if you have root access) to determine the correct mount points and file system types for each partition.
   • Update fstab: Modify the fstab file in the ramdisk to reflect these mount points and file system types. Incorrect entries here will prevent TWRP from functioning correctly.

4. init.rc and init.[device].rc: These files contain initialization scripts that are executed when TWRP starts.

   • Mounting Partitions: Review these scripts to ensure the necessary partitions are being mounted correctly.
   • SELinux: If your device uses SELinux, you might need to adjust the SELinux policies in these files to allow TWRP to access the necessary resources. This is an advanced topic that requires a solid understanding of SELinux.

5. Add TWRP Binary: Obtain the TWRP binary specifically compiled for your device’s architecture (arm, arm64). You can find pre-built binaries on the TWRP website or forums. Place the TWRP binary in the ramdisk/sbin folder and ensure it has execute permissions.

6. recovery.fstab: This file tells TWRP how to mount partitions. It’s slightly different from fstab.[device]. Add your device partitions here using the correct device name. For example:

   /system ext4 /dev/block/mmcblk0pXX flags=display="System";flashimg=1
   /data ext4 /dev/block/mmcblk0pYY flags=display="Data";wipeingui=1
   /cache ext4 /dev/block/mmcblk0pZZ flags=display="Cache";wipeingui=1
   /sdcard vfat /dev/block/mmcblk1p1 flags=display="SDCard";storage;wipeingui=1;removable
   

   Replace /dev/block/mmcblk0pXX, /dev/block/mmcblk0pYY, /dev/block/mmcblk0pZZ, and /dev/block/mmcblk1p1 with the actual partition names for your device.

3. Repacking the Recovery Image

Once you’ve modified the ramdisk, you need to repack it into a new recovery image.

1. Return to the AIK directory in the command prompt or terminal.

2. Execute the following command:

   repackimg
   

3. AIK will create a new recovery image named new-recovery.img. This is your custom TWRP recovery image.

4. Flashing the Custom TWRP

Now that you have the custom TWRP image, you can flash it to your device.

1. Enable USB Debugging: On your device, go to Settings > About phone and tap “Build number” repeatedly until Developer options are enabled. Then, go to Settings > Developer options and enable USB debugging.

2. Boot into Bootloader Mode: The method for entering bootloader mode varies depending on your device. Common methods include holding the Power button and Volume Down button simultaneously while the device is off or using the adb reboot bootloader command.

3. Flash the Recovery Image: In the command prompt or terminal, navigate to the directory where you saved new-recovery.img. Then, execute the following command:

   fastboot flash recovery new-recovery.img
   

4. Reboot into Recovery: After flashing is complete, reboot your device into recovery mode. Again, the method for doing this varies. Common methods include holding the Power button and Volume Up button simultaneously or using the fastboot reboot recovery command.

5. Testing and Troubleshooting

Once you’ve booted into TWRP, thoroughly test its functionality.

• Mounting Partitions: Verify that TWRP can correctly mount all the necessary partitions (system, data, cache, etc.).
• Backup and Restore: Attempt to create a backup of your device and then restore it.
• Flashing ZIPs: Try flashing a ZIP file (e.g., a Magisk module).
• ADB Access: Confirm that you can connect to your device via ADB while in TWRP.

If you encounter issues, carefully review the steps above and check the following:

• fstab: Double-check the entries in your fstab file to ensure they are correct.
• Permissions: Verify that the TWRP binary has execute permissions.
• Kernel Compatibility: If TWRP fails to boot or is unstable, the kernel might be incompatible. You might need to try a different kernel or adjust kernel parameters.

Leveraging GitHub Builders

GitHub-based TWRP builders offer a more automated approach to creating custom recovery images. These builders typically provide a web interface or command-line interface that allows you to specify your device details and build a TWRP image without manually modifying the ramdisk.

How to Use a GitHub TWRP Builder

1. Choose a Builder: Select a reputable TWRP builder repository on GitHub. Look for builders that are actively maintained and have positive feedback from other users.
2. Follow the Instructions: Each builder will have its own specific instructions for usage. These instructions typically involve cloning the repository, installing dependencies, and configuring the builder with your device details.
3. Provide Device Information: The builder will typically require you to provide information such as your device’s model number, Android version, and kernel configuration.
4. Build the Image: Once you’ve configured the builder, you can initiate the build process. The builder will automatically download the necessary files, modify the ramdisk, and create a TWRP image.
5. Flash and Test: After the image is built, flash it to your device and test its functionality as described above.

Advantages of Using a GitHub Builder

• Automation: Automates much of the manual work involved in building a TWRP image.
• Ease of Use: Easier to use than manually modifying the ramdisk.
• Community Support: Often have active communities that can provide support and assistance.

Disadvantages of Using a GitHub Builder

• Reliance on the Builder: You are dependent on the builder being actively maintained and providing accurate device support.
• Limited Customization: Might not offer the same level of customization as manually modifying the ramdisk.
• Security Risks: Be cautious when using third-party builders, as they could potentially contain malicious code.

Important Considerations and Precautions

• Backup Your Device: Before attempting any modifications, create a complete backup of your device. This will allow you to restore your device to its original state if something goes wrong.
• Unlock Your Bootloader: Most devices require you to unlock the bootloader before you can flash custom recovery images. Unlocking the bootloader will typically void your warranty.
• Research Thoroughly: Before making any changes, research your device and the specific steps involved in building a TWRP image.
• Be Patient: The process of building and flashing a custom recovery image can be time-consuming and require troubleshooting. Be patient and don’t give up easily.
• Join Forums and Communities: Join online forums and communities dedicated to your device. These communities can provide valuable support and assistance.
• Understand Risks: Flashing custom recovery images carries inherent risks. You could potentially brick your device if something goes wrong.

Alternative Solutions: Dynamic Partitions and A/B Devices

Many modern Android devices use A/B partitioning and/or dynamic partitions, which can complicate the process of creating a custom recovery.

• A/B Partitions: Devices with A/B partitions have two sets of system partitions (system_a and system_b). TWRP needs to be able to correctly identify and switch between these partitions.
• Dynamic Partitions: Dynamic partitions allow the system partition to be resized dynamically. TWRP needs to support dynamic partitions to be able to correctly flash ROMs and modifications.

If your device uses A/B partitions or dynamic partitions, you’ll need to ensure that the TWRP image you build supports these features. Some TWRP builders provide options for building images that are compatible with A/B partitions and dynamic partitions.

Magisk Modules and Post-Installation Tweaks

Once you have a working custom TWRP recovery, you can further enhance your device by flashing Magisk modules.

• Magisk: Magisk is a popular rooting solution that allows you to modify your device without modifying the system partition.
• Magisk Modules: Magisk modules are ZIP files that contain modifications that are applied to your device. You can find a wide variety of Magisk modules on the Magisk Module Repository.
• Post-Installation Tweaks: After flashing a custom ROM or Magisk module, you might need to perform additional tweaks to optimize your device. These tweaks could include adjusting kernel parameters, installing custom kernels, or modifying system settings.

Conclusion

Creating a custom TWRP recovery without kernel source for Chinese phones requires careful planning, thorough research, and attention to detail. While challenging, it is possible with the right tools and techniques. By following the steps outlined in this guide and taking the necessary precautions, you can unlock the full potential of your device and customize it to your liking. Remember to back up your device, research thoroughly, and be patient throughout the process. Good luck!