How can memory leaks be detected in a project?

The main tools and methods used to detect memory leaks in an Android project are:

1. Android Studio Profiler. Built-in tool for monitoring memory, CPU, network, and energy usage. It allows viewing real-time memory usage graphs and taking heap dumps.

2. Heap Dump Analysis. Analyzing a heap dump (.hprof file) helps identify which objects occupy the most memory and whether there are objects that should be garbage collected but still have strong references.

3. Memory Snapshot Comparison. Comparing two heap dumps taken at different times helps identify objects whose count is abnormally increasing, indicating a potential leak.

4. LeakCanary. A popular third-party library that automatically detects memory leaks in debug builds of the app and displays notifications. It significantly simplifies leak detection.

   Adding dependency in build.gradle:

   dependencies {
       // debugImplementation - leaks are checked only in debug builds
       debugImplementation 'com.squareup.leakcanary:leakcanary-android:2.12'
   }
   

5. StrictMode. Developer mode that helps identify operations performed on the main thread (e.g., disk reads or network requests) and object leaks (e.g., Activity, Service).

   Example of using StrictMode to detect Activity leaks:

   if (BuildConfig.DEBUG) {
       StrictMode.setVmPolicy(new StrictMode.VmPolicy.Builder()
               .detectLeakedClosableObjects() // Detect leaks of Closeable
               .detectLeakedRegistrationObjects() // Detect leaks of registered objects
               .detectActivityLeaks()           // Detect Activity leaks
               .penaltyLog()                  // Log violations
               .build());
       StrictMode.setThreadPolicy(new StrictMode.ThreadPolicy.Builder()
               .detectDiskReads()             // Detect disk reads on main thread
               .detectDiskWrites()            // Detect disk writes on main thread
               .detectNetwork()               // Detect network requests on main thread
               .penaltyLog()                  // Log violations
               .build());
   }
   

6. Code analysis. Manual code review, especially in places where contexts, listeners, asynchronous tasks, or static variables are used, which may hold references to objects with shorter lifespans.

7. Tests. Writing unit and instrumentation tests that can reproduce scenarios potentially causing leaks and programmatically check for leaks.

Each method has its advantages and disadvantages, and often the most effective approach is a combination of several tools. For example, LeakCanary quickly shows potential leaks, while Android Studio Profiler with heap dump analysis helps understand the root cause and scale of the leak.