More than one file was found with OS independent path 'META-INF/LICENSE'

You can add this in yourProject/app/build.gradle inside android{}. The exclude function adds the named resource to the list of resources that are not packaged in the APK.

android {      
      packagingOptions {
        exclude 'META-INF/DEPENDENCIES'
        exclude 'META-INF/LICENSE'
        exclude 'META-INF/LICENSE.txt'
        exclude 'META-INF/license.txt'
        exclude 'META-INF/NOTICE'
        exclude 'META-INF/NOTICE.txt'
        exclude 'META-INF/notice.txt'
        exclude 'META-INF/ASL2.0'
        exclude("META-INF/*.kotlin_module") 
      }          
}

The exclude function is deprecated in 7.0.2 and you should use something similar to this:

android {
   ...
   packagingOptions {
       resources.excludes.add("META-INF/*")
   }
}

The solutions here didn't help me, but this link did.

If you have a library that's adding some android .so files –like libassmidi.so or libgnustl_shared.so– you have to tell gradle to pick just one when packaging, otherwise you'll get the conflict.

android {
  packagingOptions {
    pickFirst 'lib/armeabi-v7a/libassmidi.so'
    pickFirst 'lib/x86/libassmidi.so'
  }
}

I was having this issue when using a React Native app as a library in an Android project. Hope it helps

I have faced a similar issue working in a multiple modules app environment:

Error: Execution failed for task ':app:transformResourcesWithMergeJavaResForDebug'. More than one file was found with OS independent path 'META-INF/AL2.0'

This issue was being reported by several of these modules of mine and none of the above solutions were fixing it. Turns out, I was using version Coroutines 1.3.6 which seemed to be embedding META-INF/AL2.0 which was already embedded by another of the libraries I was using. To fix it, I have added the following code snippet to the build.gradle of the module that was failing:

configurations.all {
    resolutionStrategy {
        exclude group: "org.jetbrains.kotlinx", module: "kotlinx-coroutines-debug"

    }
}

Given that it was happening on multiple modules, I have moved that resolutionStrategy code to my project level build.gradle. Everything worked after that.

It's perfectly safe to exclude all meta-info files which are there just for documentation and information purposes:

android{
    packagingOptions {
       exclude 'META-INF/*'
    }
}

Source: https://stackoverflow.com/a/49101232/13093413

Add the following in app level gradle file inside android{}

packagingOptions {
    exclude 'META-INF/DEPENDENCIES'
    exclude 'META-INF/LICENSE'
    exclude 'META-INF/LICENSE.txt'
    exclude 'META-INF/license.txt'
    exclude 'META-INF/NOTICE'
    exclude 'META-INF/NOTICE.txt'
    exclude 'META-INF/notice.txt'
    exclude 'META-INF/ASL2.0'
    exclude("META-INF/*.kotlin_module") 
} 

     

This happens when using

org.jetbrains.kotlinx:kotlinx-coroutines-core:1.2.0

And is fixed in next version

org.jetbrains.kotlinx:kotlinx-coroutines-core:1.2.1

I was having the same problem and I tried this

Error: More than one file was found with OS independent path 'META-INF/proguard/androidx-annotations.pro'

Solution: All you have to do to fix this is to add this to the android { } section in your app's 'build.gradle'

packagingOptions {
    exclude 'META-INF/proguard/androidx-annotations.pro'
}

I has encountered the same error, and I found that it resulted from different modules contained the same classes from different packages.

e.g. One used androidx package, and the other used pre-androidx

I solved it by migrating the pre-androidx module to androidx using built-in feature of Android Studio: "Refactor --> Migrate to Androidx..." without excluding anything.

For your situation, you may check if you have any dependency mismatches among modules.

I have read all the answers related to getting this message in Android Studio:

More than one file was found with OS independent path 'META-INF/LICENSE'

but in this case excluding classes is no neccessary, we only need to exclude 'META-INF/DEPENDENCIES', this can be done inside the /app/build.gradle:

android{
    ...
    ...
    packagingOptions {
        exclude 'META-INF/DEPENDENCIES'
    }

}

For Gradle 7.2 and later Add in-app Gradle file

android {
  
   packagingOptions {
       resources.excludes.add("META-INF/*")
   }


}

I my app, I was adding the jar dependencies like this:

implementation files('libs/json-simple-1.1.1.jar')

But I realised that they were already added because of the following first line in dependencies:

implementation fileTree(include: ['*.jar'], dir: 'libs')

This line adds all the jars in lib folder to app dependency.

Hence after removing the extra dependency implementation files('libs/json-simple-1.1.1.jar')

it is working fine.

I updated Studio from Java 7 to Java 8, and this problem occurred. Then I solved it this way:

android {
    defaultConfig {
    }
    buildTypes {
    }
    packagingOptions{
        exclude 'META-INF/rxjava.properties'
    }
}

This work for me

packagingOptions {
   exclude 'META-INF/*'
}

Based on the answers provided by @JohnnyLambada and @Shaaban Ebrahim

For excluding nested files, I used the following.

    packagingOptions {
        resources.excludes.add("META-INF/**/*")
    }

PS: Not spamming with same answer, but just a suggestion if you get an error something like

4 files found with path 'META-INF/gradle/incremental.annotation.processors'.

which catches errors from nested directories and FYI I had setup my dependencies using kotlin-dsl

Adding

android.useAndroidX=true

android.enableJetifier=true

to gradle.properties worked for me.

Since it's not already mentioned, you may alternatively merge the files to stay in accordance with license requirements (or just use pickFirst as stated by Daniel Reina).

packagingOptions {
    merge "META-INF/LICENSE"
    merge "META-INF/AL2.0"
    merge "META-INF/LGPL2.1"
}

Reference: Gradle API 4.2 Packaging Options

I'm having same problem and I tried this

Error: More than one file was found with OS independent path 'META-INF/library_release.kotlin_module'

Solution:

android {
    packagingOptions {
    exclude 'META-INF/library_release.kotlin_module'
    }
}

This error is caused by adding a support library instead of AndroidX. Make sure you use which one:

for AndroidX:

dependencies {
    def multidex_version = "2.0.1"
    implementation 'androidx.multidex:multidex:$multidex_version'
}

If you aren't using AndroidX:

dependencies {
  implementation 'com.android.support:multidex:1.0.3'
}

Also in manifest use the application class name instead of "android.support.multidex.MultiDexApplication" in the application tag(my application class name is G):

the mistake:

<application
            android:name="android.support.multidex.MultiDexApplication" >
        ...
</application>

right:

<application
            android:name=".G" >
        ...
</application>

Worked for me. Add these to your app's build.gradle within the android{} block.

packagingOptions {
    exclude 'META-INF/AL2.0'
    exclude 'META-INF/LGPL2.1'
}

put this inside the build.gradle (Module AppName)

android {
   // ....
   packagingOptions{
     pickFirst "androidsupportmultidexversion.txt"
  }
}

in gradle 7.2 and above you can fix the problem like this:

in your app/build.gradle in android block:

  packagingOptions {
        resources.excludes.add("META-INF/notice.txt")
        resources.merges.add("META-INF/LICENSE")
        resources.merges.add("META-INF/AL2.0")
        resources.merges.add("META-INF/LGPL2.1")
    }

I faced this issue, first with some native libraries (.so files) and then with java/kotlin files. Turned out I was including a library from source as well as referencing artifactory through a transitive dependency. Check your dependency tree to see if there are any redundant entries. Use ./gradlew :app:dependencies to get the dependency tree. Replace "app" with your module name if the main module name is different.

Try to remove multidex from default config and check the build error log. If that log is some relatable with INotification class. Use this in android{}

configurations {
    all*.exclude group: 'com.android.support', module: 'support-v4'
}

This helps me.

In many of the answers on SO on this problem it has been suggested to add exclude 'META-INF/DEPENDENCIES' and some other excludes. However none of these worked for me. In my case scenario was like this:

I had added this in dependancies:

implementation 'androidx.annotation:annotation:1.1.0'

And also I had added this in gradle.properties:

android.useAndroidX=true

Both of these I had added, because I was getting build error 'cannot find symbol class Nullable' and it was suggested as solution to this on some of answers like here

However, eventually I landed up in getting error:

 More than one file was found with OS independent path 'androidsupportmultidexversion.txt'

No exclude was working for me. Finally I just removed those added lines above just out of suspecion (Solved 'cannot find symbol class Nullable' in some alternative way) and finally I got rid of this "More than one file was found with OS..." build error. I wasted hours of mine. But finally got rid of it.

If you have this problem and you have a gradle .jar dependency, like this:

implementation group: 'org.mortbay.jetty', name: 'jetty', version: '6.1.26'

Interval versions until one matches and resolves the excepetion,and apply the best answer of this thread.`

If you work with multi module project and face this issue while espresso testing, you need to add packagingOptions code each gradle file. In my case , I added below code for each gradle file.

packagingOptions {
    exclude 'META-INF/lib_release.kotlin_module'
}

Add multiDexEnabled true inside android {}

And remove implementation 'com.android.support:multidex:x.x.x' from dependencies

In my case code bellow worked, In your

app build.gradle

file add

android {    
    ..
    packagingOptions {
        pickFirst  '**'
    }
    ..
}