How to rename an Android project: a complete guide with code examples

Open the file app/build.gradle (or build.gradle your module) and find the block:

android {
defaultConfig {
applicationId "com.oldcompany.oldapp"
// other settings...
}
}

Replace the value applicationId with a new one, for example:

applicationId "com.newcompany.newapp"

After that:

1. Synchronize the project with Gradle (File → Sync Project with Gradle Files).
2. Clean the project (Build → Clean Project).
3. Rebuild the APK (Build → Rebuild Project).

This is enough if:

• ✅ You do not change the physical structure of the packages (for example, com.oldcompany.oldapp → com.newcompany.newapp, but the files remain in the same folder).
• ✅ Your application does not use Broadcast Receivers or Servicesregistered in the manifest with an explicit package indication.
• ✅ You do not plan to publish the update to Google Play under the same certificate (in this case applicationId should remain the same).

Method 2: Complete renaming the package (structure + code)

If you need to change not only applicationId, but also physical location of files (for example, move classes from com.oldcompany.oldapp to com.newcompany.newapp), use the built-in tool Refactor in Android Studio.

Step-by-step guide:

1. Open Project View (left panel, select Project in the drop-down menu).
2. Find the root package of your application (usually app/src/main/java/com/oldcompany/oldapp).
3. Right-click on the package folder and select Refactor → Rename.
4. In the window that appears, enter a new package name (for example, com.newcompany.newapp) and click Refactor.
5. Confirm changes in all files (Android Studio will prompt you to update imports, manifest and Gradle).

What happens under the hood:

After refactoring:

• 🔍 Check all files with the extension .xml (especially layouts i menus) for links to old classes.
• 🔧 Run Invalidate Caches / Restart (File → Invalidate Caches).
• 📱 Test the application on the device - some Broadcast Receivers or Content Providers may not register due to incorrect paths.

Method 3: Renaming through the terminal (for experienced)

If you prefer to work with the command line or need to rename hundreds of files using a template, you can use a combination sed, find i mv. This method riskybut gives full control over the process.

Example script for renaming a package com.oldcompany.oldapp → com.newcompany.newapp:

#!/bin/bash
OLD_PACKAGE="com/oldcompany/oldapp"
NEW_PACKAGE="com/newcompany/newapp"

1. Rename folders
find . -type d -name "$OLD_PACKAGE" | while read dir; do
new_dir="${dir//$OLD_PACKAGE/$NEW_PACKAGE}"
mv "$dir" "$new_dir"
done

2. Replace imports in Java/Kotlin files
find . -name ".java" -o -name ".kt" | xargs sed -i "" "s/$OLD_PACKAGE/$NEW_PACKAGE/g"

3. Update AndroidManifest.xml
sed -i "" "s/package=\"$OLD_PACKAGE\"/package=\"$NEW_PACKAGE\"/g" app/src/main/AndroidManifest.xml

4. Update build.gradle
sed -i "" "s/applicationId \""$OLD_PACKAGE\"/applicationId \""$NEW_PACKAGE"\"/g" app/build.gradle

Warnings:

• 🚨 This script does not handle cases when the package name appears in strings (for example, in logs or comments).
• 🚨 For Windows replace sed -i "" with sed -i (without quotes).
• 🚨 Before running required test the script on a copy project.

After executing the script:

1. Delete folders build and .idea.
2. Open the project in Android Studio and wait indexing.
3. Run Build → Clean Project and Build → Rebuild Project.

⚠️ Attention: If your project uses Dagger 2, Room or other code-generating libraries, after renaming packages you may need to clear the annotation cache (Build → Clean Project + delete folders app/build/generated).

Problems after renaming and their solutions

Even with careful renaming, errors may occur. Here are the most common ones and how to fix them:

If after renaming the project no longer builds:

1. Return to the last one working commit (git checkout last_commit).
2. Repeat the rename, but step by step (first applicationId, then packages, then manifest).
3. Use git diffto see which files were modified incorrectly.

Renaming for multi-module projects

If your project consists of several modules (for example :app, :core, :feature-auth), the process becomes more complicated:

1. Update settings.gradle:

   include ':app', ':core', ':feature-auth'
   rootProject.name = "NewProjectName"

2. For each module, update build.gradle (if it has its own applicationId for tests).
3. Check inter-module dependencies:

   implementation project(':core')

   Make sure that the paths to the modules do not contain old names.

4. Update AndroidManifest.xml in each module (if any).

Features for Dynamic Feature Modules:

• 📦 The package name in the module manifest must match the main one applicationId.
• 🔗 In build.gradle module, check:

  android {
  dynamicFeatures = [":feature-auth"]
  }

• 🔄 After renaming, run BundleTool to generate a new .aab.

For projects with Flavors (different assemblies for dev, prod):

• 🍭 Update applicationIdSuffix to build.gradle:

  productFlavors {
  dev {
  applicationIdSuffix ".dev"
  }
  prod {
  // without suffix
  }
  }

• 🔧 Check manifestPlaceholdersif they use ${applicationId}.

How rename the project for Google Play

If your application is already published in Google Play Consolerenaming requires special care. It is important to distinguish here:

• 📛 Package name. (applicationId) — cannot change for an existing application This will create a new listing.
• 🏷️ Application name (android:label) —can be changed without restrictions.
• 📂 Package structure in code —can be changed, but this will not affect the published application.

If you you still need to change applicationId (for example, when rebranding a company):

1. Create new app in Google Play Console s new applicationId.
2. Publish it as a separate product (the old app will remain available).
3. Use deep links or promo pagesto redirect users from the old app to the new one.
4. If necessary, export reviews and statistics via Google Play API.

To change display name applications (what users see in Play Market):

1. Open app/src/main/res/values/strings.xml.
2. Find the line:

   Old name

3. Replace it with a new name:

   New name

4. Update the name in Google Play Console (section Store Listing → App Name).

⚠️ Attention: If you use Firebase or Google Analytics, renaming applicationId will require creating a new project in these services and transferring data manually.

FAQ: Frequently asked questions about renaming Android projects

git log --follow -p -- path/to/renamed/file

git add -A
git commit -m "Rename package from old to new"

# Old:
target_include_directories(native-lib PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/../../../java/com/oldcompany/oldapp)

New:
target_include_directories(native-lib PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/../../../java/com/newcompany/newapp)