### Basic Test Rule Chain Setup

Source: https://github.com/square/leakcanary/blob/main/docs/ui-tests.md

An example of a basic test rule chain setup without LeakCanary's specific rules.

```kotlin
import org.junit.Rule
import org.junit.rules.RuleChain

// Example test rule chain
@get:Rule
val rule = RuleChain.outerRule(LoginRule())
  .around(ActivityScenarioRule(CartActivity::class.java))
  .around(LoadingScreenRule())

```

--------------------------------

### Install Shark CLI with Homebrew

Source: https://github.com/square/leakcanary/blob/main/docs/shark.md

Install the Shark CLI using Homebrew. This is the recommended method for installation.

```bash
brew install leakcanary-shark
```

--------------------------------

### Manually Install AppWatchers

Source: https://github.com/square/leakcanary/blob/main/docs/recipes.md

Specify which watchers to install via AppWatcher.manualInstall() to customize runtime detection. This example excludes FragmentAndViewModelWatcher.

```kotlin
val watchersToInstall = AppWatcher.appDefaultWatchers(this)
  .filter { it !is FragmentAndViewModelWatcher }
AppWatcher.manualInstall(
  application = this,
  watchersToInstall = watchersToInstall
)
```

--------------------------------

### Install Docs Dependencies

Source: https://github.com/square/leakcanary/blob/main/docs/dev-env.md

Install or update the documentation dependencies using pip.

```bash
pip install --requirement docs/requirements.txt
```

--------------------------------

### Set up Python virtual environment and install dependencies

Source: https://github.com/square/leakcanary/blob/main/docs/releasing.md

Sets up a Python virtual environment and installs the necessary Python packages for documentation generation and deployment. This ensures a consistent build environment.

```bash
python3 -m venv venv
source venv/bin/activate
pip3 install --requirement docs/requirements.txt
```

--------------------------------

### Install GitHub CLI and jq

Source: https://github.com/square/leakcanary/blob/main/docs/releasing.md

Installs the GitHub CLI and jq, which are required for interacting with GitHub and processing JSON data, respectively. Use this command on macOS with Homebrew.

```bash
brew install gh jq
```

--------------------------------

### Default Setup Code (Before LeakCanary 2.0)

Source: https://github.com/square/leakcanary/blob/main/docs/upgrading-to-leakcanary-2.0.md

Illustrates the default LeakCanary setup code in an Application class before version 2.0. This includes a check for the analyzer process.

```java
public class ExampleApplication extends Application {

  @Override public void onCreate() {
    super.onCreate();
    if (LeakCanary.isInAnalyzerProcess(this)) {
      // This process is dedicated to LeakCanary for heap analysis.
      // You should not init your app in this process.
      return;
    }
    LeakCanary.install(this);
    // Normal app init code...
  }
}
```

--------------------------------

### Install LeakCanary and Explore Heap Dump with Neo4j

Source: https://github.com/square/leakcanary/blob/main/docs/changelog.md

Install LeakCanary using Homebrew. Then, use the shark-cli command to convert a heap dump into a Neo4j database and explore it.

```bash
brew install leakcanary-shark
```

```bash
shark-cli --process com.example.app.debug neo4j
```

--------------------------------

### Accessing Installed Ref Watcher

Source: https://github.com/square/leakcanary/blob/main/docs/changelog.md

Retrieves the singleton instance of the installed ref watcher.

```APIDOC
## Accessing Installed Ref Watcher

### Description
The installed ref watcher singleton is now available for direct access.

### Method
`LeakCanary.installedRefWatcher()`

### Parameters
None

### Response
- **RefWatcher** - The singleton instance of the installed ref watcher.
```

--------------------------------

### Replace LeakCanary Dependency with Startup Variant

Source: https://github.com/square/leakcanary/blob/main/docs/changelog.md

Use leakcanary-android-startup instead of leakcanary-android to integrate with the AndroidX App Startup library. This is an alternative setup for automatic LeakCanary installation.

```groovy
dependencies {
  // Remove the normal leakcanary-android dependency
  // debugImplementation 'com.squareup.leakcanary:leakcanary-android:2.8'
  debugImplementation 'com.squareup.leakcanary:leakcanary-android-startup:2.8'
}
```

--------------------------------

### Print Thread Names from Heap Graph

Source: https://github.com/square/leakcanary/blob/main/docs/shark.md

This Kotlin example demonstrates how to index an Hprof file into a heap graph and then extract and print the names of all threads.

```kotlin
import java.io.File
import shark.Hprof
import shark.HprofHeapGraph

fun main(args: Array<String>) {
  val heapDumpFile = File(args[0])

  // Prints all thread names
  Hprof.open(heapDumpFile).use { hprof ->
    val heapGraph = HprofHeapGraph.indexHprof(hprof)
    val threadClass = heapGraph.findClassByName("java.lang.Thread")!!
    val threadNames: Sequence<String> = 
      threadClass.instances.map { instance ->
        val nameField = instance["java.lang.Thread", "name"]!!
        nameField.value.readAsJavaString()!!
      }
    threadNames.forEach { println(it) }
  }
}
```

--------------------------------

### Configure LeakCanary: Before 2.0

Source: https://github.com/square/leakcanary/blob/main/docs/upgrading-to-leakcanary-2.0.md

In LeakCanary versions prior to 2.0, LeakCanary was installed directly within the application class. This example shows the older method of installing LeakCanary with specific watch settings.

```java
public class DebugExampleApplication extends ExampleApplication {

  @Override protected void installLeakCanary() {
    RefWatcher refWatcher = LeakCanary.refWatcher(this)
      .watchActivities(false)
      .buildAndInstall();
  }
}
```

--------------------------------

### Heap Growth Detector Setup for Espresso

Source: https://github.com/square/leakcanary/blob/main/docs/changelog.md

This Kotlin code sets up a `LiveHeapGrowthDetector` for in-process Espresso UI tests. It configures heap dumping, reference matching, and the detection logic. Ensure the heap dump directory exists and is accessible.

```kotlin
import leakcanary.AndroidDebugHeapDumper
import shark.AndroidReferenceMatchers
import shark.AndroidReferenceReaderFactory
import shark.CloseableHeapGraph
import shark.DiffingHeapGrowthDetector
import shark.HeapGraphProvider
import shark.HprofHeapGraph.Companion.openHeapGraph
import shark.IgnoredReferenceMatcher
import shark.LiveHeapGrowthDetector
import shark.LoopingHeapGrowthDetector
import shark.MatchingGcRootProvider
import shark.ReferencePattern.InstanceFieldPattern
import java.io.File
import java.text.SimpleDateFormat
import java.util.Date
import java.util.Locale

/**
 * Heap growth detector for in process Espresso UI tests.
 *
 * Call [LiveHeapGrowthDetector.detectRepeatedHeapGrowth] with a scenario to repeat, then assert that the resulting [shark.HeapTraversalWithDiff.growingNodes] is empty.
 */
val HeapGrowthDetector by lazy {
  val referenceMatchers = AndroidReferenceMatchers.appDefaults +
    HeapTraversal.ignoredReferences +
    // https://cs.android.com/android/_/android/platform/frameworks/base/+/6985fb39f07294fb979b14ba0ebabfd2fea06d34
    IgnoredReferenceMatcher(InstanceFieldPattern("android.os.StrictMode", "sLastVmViolationTime"))

  val dateFormat = SimpleDateFormat("yyyy-MM-dd_HH-mm-ss_SSS'-heap-growth.hprof'", Locale.US)
  val uploadedTracesDirectory = File("/sdcard/traces/")
  uploadedTracesDirectory.mkdirs()
  check(uploadedTracesDirectory.exists()) {
    "Expected heap dump folder to exist: ${uploadedTracesDirectory.absolutePath}"
  }

  val heapGraphProvider = HeapGraphProvider {
    val fileName = dateFormat.format(Date())
    val heapDumpFile = File(uploadedTracesDirectory, fileName)
    AndroidDebugHeapDumper.dumpHeap(heapDumpFile)
    check(heapDumpFile.exists()) {
      "Expected file to exist after heap dump: ${heapDumpFile.absolutePath}"
    }
    val realGraph = heapDumpFile.openHeapGraph()
    object : CloseableHeapGraph by realGraph {
      override fun close() {
        realGraph.close()
        heapDumpFile.delete()
      }
    }
  }

  LiveHeapGrowthDetector(
    maxHeapDumps = 5,
    heapGraphProvider = heapGraphProvider,
    scenarioLoopsPerDump = 5,
    detector = LoopingHeapGrowthDetector(
      DiffingHeapGrowthDetector(
        referenceReaderFactory = AndroidReferenceReaderFactory(referenceMatchers),
        gcRootProvider = MatchingGcRootProvider(referenceMatchers)
      )
    )
  )
}

```

--------------------------------

### Manually Install LeakCanary Watchers (Excluding ServiceWatcher)

Source: https://github.com/square/leakcanary/blob/main/docs/changelog.md

Manually install LeakCanary watchers by filtering out the ServiceWatcher from the default list. This is useful when you need fine-grained control over which watchers are active.

```kotlin
class DebugExampleApplication : ExampleApplication() {

  override fun onCreate() {
    super.onCreate()

    val watchersToInstall = AppWatcher.appDefaultWatchers(application)
      .filter { it !is ServiceWatcher }

    AppWatcher.manualInstall(
      application = application,
      watchersToInstall = watchersToInstall
    )
  }
}
```

--------------------------------

### Configure LeakCanary Analysis (Java)

Source: https://github.com/square/leakcanary/blob/main/docs/recipes.md

Customize heap dumping and analysis settings in Java using LeakCanary.Config.Builder. This example sets the retained visible threshold.

```java
LeakCanary.Config config = LeakCanary.getConfig().newBuilder()
   .retainedVisibleThreshold(3)
   .build();
LeakCanary.setConfig(config);
```

--------------------------------

### Example Library Leak Pattern

Source: https://github.com/square/leakcanary/blob/main/docs/fundamentals-how-leakcanary-works.md

This example shows how LeakCanary identifies a Library Leak by pattern matching on reference names, highlighting a specific instance field and its reference chain.

```text
Leak pattern: instance field android.app.Activity$1#this$0
Description: Android Q added a new IRequestFinishCallback$Stub class [...]
┬───
│ GC Root: Global variable in native code
│
├─ android.app.Activity$1 instance
│    Leaking: UNKNOWN
│    Anonymous subclass of android.app.IRequestFinishCallback$Stub
│    ↓ Activity$1.this$0
│                 ~~~~~~
╰→ com.example.MainActivity instance
```

--------------------------------

### Generate Android Heap Analysis Report

Source: https://github.com/square/leakcanary/blob/main/docs/shark.md

This Kotlin example extends the general heap analysis by incorporating Android-specific reference matchers and object inspectors for more accurate Android heap analysis.

```kotlin
import java.io.File
import shark.AndroidObjectInspectors
import shark.AndroidReferenceMatchers
import shark.FilteringLeakingObjectFinder
import shark.FilteringLeakingObjectFinder.LeakingObjectFilter
import shark.HeapAnalyzer
import shark.HeapObject
import shark.HeapObject.HeapInstance
import shark.Hprof
import shark.HprofHeapGraph

// Marks any instance of com.example.ThingWithLifecycle with
// ThingWithLifecycle.destroyed=true as leaking
val leakingObjectFilter = 
  object : LeakingObjectFilter {
    override fun isLeakingObject(heapObject: HeapObject): Boolean {
      return if (
        heapObject is HeapInstance && heapObject instanceOf "com.example.ThingWithLifecycle"
      ) {
        val instance = heapObject as HeapInstance
        val destroyedField = instance["com.example.ThingWithLifecycle", "destroyed"]!!
        destroyedField.value.asBoolean!!
      } else false
    }
  }

val leakingObjectFinder = FilteringLeakingObjectFinder(listOf(leakingObjectFilter))

fun main(args: Array<String>) {
  val heapDumpFile = File(args[0])

  val heapAnalysis = 
    Hprof.open(heapDumpFile).use { hprof ->
      val heapGraph = HprofHeapGraph.indexHprof(hprof)
      val heapAnalyzer = HeapAnalyzer({})
      heapAnalyzer.analyze(
        heapDumpFile = heapDumpFile,
        graph = heapGraph,
        leakingObjectFinder = leakingObjectFinder,
        referenceMatchers = AndroidReferenceMatchers.appDefaults,
        objectInspectors = AndroidObjectInspectors.appDefaults,
      )
    }

  println(heapAnalysis)
}
```

--------------------------------

### Initial Leak Trace Highlighting All Suspect References

Source: https://github.com/square/leakcanary/blob/main/docs/fundamentals-fixing-a-memory-leak.md

This is an example of an initial leak trace produced by LeakCanary, where all references in the path are initially suspected and highlighted.

```text
┬───
│ GC Root: System class
│
├─ android.provider.FontsContract class
│    ↓ static FontsContract.sContext
├─ com.example.leakcanary.ExampleApplication instance
│    ↓ ExampleApplication.leakedViews
├─ java.util.ArrayList instance
│    ↓ ArrayList.elementData
├─ java.lang.Object[] array
│    ↓ Object[].[0]
├─ android.widget.TextView instance
│    ↓ TextView.mContext
╰→ com.example.leakcanary.MainActivity instance
```

--------------------------------

### HashMap Leak Trace Example

Source: https://github.com/square/leakcanary/blob/main/docs/changelog.md

Demonstrates a typical leak trace for a HashMap before improved data structure support. This shows the internal structure of the HashMap, which can be less intuitive for developers.

```kotlin
class CheckoutController {

  val tabs = HashMap<String, Tab>()

  fun addItemsTab(tab: Tab) {
    tabs["ItemsTab"] = tab
  }
}
```

```text
│ ...
├─ com.example.CheckoutController instance
│    ↓ CheckoutController.tabs
├─ java.util.HashMap instance
│    ↓ HashMap.table
├─ java.util.HashMap$Node[] array
│    ↓ HashMap$Node[42]
├─ java.util.HashMap$Node instance
│    ↓ HashMap$Node.next
├─ java.util.HashMap$Node instance
│    ↓ HashMap$Node.value
├─ com.example.Tab instance
│ ...
```

--------------------------------

### Configure LeakCanary Analysis

Source: https://github.com/square/leakcanary/blob/main/docs/recipes.md

Customize heap dumping and analysis settings by updating LeakCanary.config. This example sets the retained visible threshold.

```kotlin
LeakCanary.config = LeakCanary.config.copy(retainedVisibleThreshold = 3)
```

--------------------------------

### Manually Install LeakCanary Watchers with Custom ReachabilityWatcher

Source: https://github.com/square/leakcanary/blob/main/docs/changelog.md

Install LeakCanary watchers with a custom ReachabilityWatcher that filters out specific objects, such as BadSdkLeakingFragment, before delegating to the default object watcher.

```kotlin
class DebugExampleApplication : ExampleApplication() {

  override fun onCreate() {
    super.onCreate()

    val delegate = ReachabilityWatcher { watchedObject, description ->
      if (watchedObject !is BadSdkLeakingFragment) {
        AppWatcher.objectWatcher.expectWeaklyReachable(watchedObject, description)
      }
    }

    val watchersToInstall = AppWatcher.appDefaultWatchers(application, delegate)

    AppWatcher.manualInstall(
      application = application,
      watchersToInstall = watchersToInstall
    )
  }
}
```

--------------------------------

### Display View Resource ID in LeakTrace

Source: https://github.com/square/leakcanary/blob/main/docs/changelog.md

This example shows how a View instance's resource ID is displayed in the LeakTrace. This information is useful for debugging UI-related leaks.

```text
├─ android.widget.TextView instance
│    View.mID = R.id.helper_text
```

--------------------------------

### Example Leak Trace

Source: https://github.com/square/leakcanary/blob/main/docs/fundamentals-fixing-a-memory-leak.md

This is an example of a leak trace provided by LeakCanary, illustrating the strong reference path from a garbage collection root to a retained object. It helps in diagnosing memory leaks.

```text
┬───
│ GC Root: Local variable in native code
│
├─ dalvik.system.PathClassLoader instance
│    ↓ PathClassLoader.runtimeInternalObjects
├─ java.lang.Object[] array
│    ↓ Object[].[43]
├─ com.example.Utils class
│    ↓ static Utils.helper
╰→ java.example.Helper
```

--------------------------------

### Espresso Test for Heap Growth Detection

Source: https://github.com/square/leakcanary/blob/main/docs/changelog.md

Example of an Espresso test using `ObjectGrowthDetector` to find repeatedly growing objects during UI interactions. Asserts that no objects are found to be growing.

```kotlin
class MyEspressoTest {
  val detector = ObjectGrowthDetector
    .forAndroidHeap()
    .repeatingAndroidInProcessScenario()

  @Test
  fun greeter_says_hello_does_not_leak() {
    // Runs repeatedly until the heap stops growing or we reach max heap dumps.
    val heapGrowth = detector.findRepeatedlyGrowingObjects {
      onView(withId(R.id.name_field)).perform(typeText("Steve"))
      onView(withId(R.id.greet_button)).perform(click())
      onView(withText("Hello Steve!")).check(matches(isDisplayed()))
    }

    assertThat(heapGrowth.growingObjects).isEmpty()
  }
}
```

--------------------------------

### Disable LeakCanary Auto Install

Source: https://github.com/square/leakcanary/blob/main/docs/changelog.md

To disable the automatic installation of LeakCanary watchers, set this boolean resource to false in your project's values.

```xml
<?xml version="1.0" encoding="utf-8"?>
<resources>
  <bool name="leak_canary_watcher_auto_install">false</bool>
</resources>
```

--------------------------------

### Configure LeakCanary from Java

Source: https://github.com/square/leakcanary/blob/main/docs/changelog.md

Use LeakCanary.Config.Builder for idiomatic Java configuration. This example sets the retained visible threshold and disables computing retained heap size.

```java
LeakCanary.Config config = LeakCanary.getConfig().newBuilder()
  .retainedVisibleThreshold(3)
  .computeRetainedHeapSize(false)
  .build();
LeakCanary.setConfig(config);
```

--------------------------------

### UI Automator Test for Heap Growth Detection

Source: https://github.com/square/leakcanary/blob/main/docs/changelog.md

Example of a UI Automator test using `ObjectGrowthDetector` to monitor heap growth during UI interactions. It checks that no growing objects are detected.

```kotlin
class MyUiAutomatorTest {
  val detector = ObjectGrowthDetector
    .forAndroidHeap()
    .repeatingUiAutomatorScenario()

  @Test
  fun clicking_welcome_does_not_leak() {
    val device = UiDevice.getInstance(InstrumentationRegistry.getInstrumentation())
    // Runs repeatedly until the heap stops growing or we reach max heap dumps.
    val heapGrowth = detector.findRepeatedlyGrowingObjects {
      device.findObject(By.text("Welcome!")).click()
    }

    assertThat(heapGrowth.growingObjects).isEmpty()
  }
}
```

--------------------------------

### Leak Trace with Suspect References

Source: https://github.com/square/leakcanary/blob/main/docs/fundamentals-how-leakcanary-works.md

This example shows a leak trace where suspect references are underlined with '~' characters. This format is used when sharing leak traces as text.

```text
│  
├─ com.example.leakcanary.LeakingSingleton class
│    Leaking: NO (a class is never leaking)
│    ↓ static LeakingSingleton.leakedViews
│                              ~~~~~~~~~~~
├─ java.util.ArrayList instance
│    Leaking: UNKNOWN
│    ↓ ArrayList.elementData
│                ~~~~~~~~~~~
├─ java.lang.Object[] array
│    Leaking: UNKNOWN
│    ↓ Object[].[0]
│               ~~~
├─ android.widget.TextView instance
│    Leaking: YES (View.mContext references a destroyed activity)
...
```

--------------------------------

### Espresso Test for Heap Growth Detection

Source: https://github.com/square/leakcanary/blob/main/docs/changelog.md

An example of an Espresso test that uses HeapDiff to detect heap growth during UI interactions. The test asserts that no objects are growing in the heap.

```kotlin
class MyEspressoTest {
  val detector = HeapDiff.repeatingAndroidInProcessScenario()

  @Test
  fun greeter_says_hello_does_not_grow_heap() {
    // Runs repeatedly until the heap stops growing or we reach max heap dumps.
    val heapDiff = detector.findRepeatedlyGrowingObjects {
      onView(withId(R.id.name_field)).perform(typeText("Steve"))
      onView(withId(R.id.greet_button)).perform(click())
      onView(withText("Hello Steve!")).check(matches(isDisplayed()))
    }

    assertThat(heapDiff.growingObjects).isEmpty()
  }
}
```

--------------------------------

### Improved HashMap Leak Trace Example

Source: https://github.com/square/leakcanary/blob/main/docs/changelog.md

Illustrates the clearer leak trace provided by LeakCanary after improved data structure support. It surfaces the key used in the HashMap and simplifies the representation of internal nodes.

```text
│ ...
├─ com.example.CheckoutController instance
│    ↓ CheckoutController.tabs
├─ java.util.HashMap instance
│    ↓ HashMap[ItemsTab]
├─ com.example.Tab instance
│ ...
```

--------------------------------

### UI Automator Test for Heap Growth Detection

Source: https://github.com/square/leakcanary/blob/main/docs/changelog.md

An example of a UI Automator test that uses HeapDiff to detect heap growth during UI interactions. The test clicks a UI element and asserts that no objects are growing in the heap.

```kotlin
class MyUiAutomatorTest {
  val detector = HeapDiff.repeatingUiAutomatorScenario()

  @Test
  fun clicking_welcome_does_not_grow_heap() {
    val device = UiDevice.getInstance(InstrumentationRegistry.getInstrumentation())
    // Runs repeatedly until the heap stops growing or we reach max heap dumps.
    val heapDiff = detector.findRepeatedlyGrowingObjects {
      device.findObject(By.text("Welcome!")).click()
    }

    assertThat(heapDiff.growingObjects).isEmpty()
  }
}
```

--------------------------------

### Detect Leaks Before Activity Destroyed

Source: https://github.com/square/leakcanary/blob/main/docs/ui-tests.md

Configure `DetectLeaksAfterTestSuccess` to run before the activity is destroyed. This setup might detect more fragment leaks but could miss leaks that are resolved when the activity is destroyed.

```kotlin
import org.junit.Rule
import org.junit.rules.RuleChain

@get:Rule
val rule = RuleChain.outerRule(LoginRule())
  .around(ActivityScenarioRule(CartActivity::class.java))
  // Detect leaks BEFORE activity is destroyed
  .around(DetectLeaksAfterTestSuccess(tag = "BeforeActivityDestroyed"))
  .around(LoadingScreenRule())

```

--------------------------------

### Check LeakCanary Running Status

Source: https://github.com/square/leakcanary/blob/main/docs/faq.md

Verify LeakCanary is active by filtering Logcat for the 'LeakCanary' tag. Look for the 'Installing AppWatcher' message to confirm successful initialization.

```bash
$ adb logcat | grep LeakCanary

D/LeakCanary: Installing AppWatcher
```

--------------------------------

### Add Plumber-Android Dependency

Source: https://github.com/square/leakcanary/blob/main/docs/changelog.md

Example of how to include plumber-android in your project dependencies. Leakcanary-android includes plumber-android by default for debug builds.

```gradle
dependencies {
  // leakcanary-android adds plumber-android to debug builds
  debugImplementation 'com.squareup.leakcanary:leakcanary-android:2.6'

  // This adds plumber-android to all build types
  implementation 'com.squareup.leakcanary:plumber-android:2.6'
}
```

--------------------------------

### Skip LeakCanary Initialization in Analyzer Process

Source: https://github.com/square/leakcanary/blob/main/docs/changelog.md

Prevent LeakCanary initialization in the analyzer process to avoid conflicts. This setup is for multi-process configurations.

```kotlin
class ExampleApplication : Application() {

  override fun onCreate() {
    if (LeakCanaryProcess.isInAnalyzerProcess(this)) {
      return
    }
    super.onCreate()
    // normal init goes here, skipped in :leakcanary process.
  }
}
```

--------------------------------

### Deobfuscate Hprof Files with Shark CLI

Source: https://github.com/square/leakcanary/blob/main/docs/changelog.md

The Shark CLI can now deobfuscate heap dumps. Ensure you have installed the leakcanary-shark package via Homebrew.

```bash
brew install leakcanary-shark

shark-cli --hprof heapdump.hprof -m mapping.txt deobfuscate-hprof
```

--------------------------------

### Detect ObjectAnimator Leaks in Kotlin

Source: https://github.com/square/leakcanary/blob/main/docs/changelog.md

This code demonstrates how to start an infinite ObjectAnimator without canceling it, which LeakCanary can now detect. Ensure ObjectAnimator is properly canceled to prevent leaks.

```kotlin
class ExampleActivity : Activity() {

  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.main_activity)
    findViewById<Button>(R.id.button).setOnClickListener { view ->
      ObjectAnimator.ofFloat(view, View.ALPHA, 0.1f, 0.2f).apply {
        duration = 100
        repeatMode = ValueAnimator.REVERSE
        repeatCount = ValueAnimator.INFINITE
        start()
      }
    }
  }
}
```

```text
┬───
│ GC Root: Thread object
│
├─ java.lang.Thread instance
│    Leaking: NO (the main thread always runs)
│    Thread name: 'main'
│    ↓ Thread.threadLocals
│             ~~~~~~~~~~~~
...
├─ android.animation.ObjectAnimator instance
│    Leaking: UNKNOWN
│    mListeners = null
│    mPropertyName = null
│    mProperty.mName = alpha
│    mProperty.mType = java.lang.Float
│    mInitialized = true
│    mStarted = true
│    mRunning = true
│    mAnimationEndRequested = false
│    mDuration = 100
│    mStartDelay = 0
│    mRepeatCount = INFINITE (-1)
│    mRepeatMode = REVERSE (2)
│    ↓ ObjectAnimator.mTarget
│                     ~~~~~~~
╰→ android.widget.Button instance
     Leaking: YES (View.mContext references a destroyed activity)
```

--------------------------------

### GC Root Example: PathClassLoader

Source: https://github.com/square/leakcanary/blob/main/docs/fundamentals-fixing-a-memory-leak.md

This snippet shows a portion of a leak trace, highlighting a GC root of type 'Local variable in native code' and the reference path leading to a PathClassLoader instance. This is part of diagnosing memory leaks.

```text
┬───
│ GC Root: Local variable in native code
│
├─ dalvik.system.PathClassLoader instance
```

--------------------------------

### Configure Release Heap Analysis

Source: https://github.com/square/leakcanary/blob/main/docs/leakcanary-for-releases.md

Set up LeakCanary to automatically trigger heap analysis when the app enters the background or the screen turns off. This example also shows how to conditionally enable analysis via a Firebase Remote Config flag and upload results to Bugsnag.

```kotlin
import android.os.Process.THREAD_PRIORITY_BACKGROUND
import java.util.concurrent.Executors
import kotlin.concurrent.thread
import leakcanary.BackgroundTrigger
import leakcanary.HeapAnalysisClient
import leakcanary.HeapAnalysisConfig
import leakcanary.HeapAnalysisInterceptor
import leakcanary.HeapAnalysisInterceptor.Chain
import leakcanary.HeapAnalysisJob
import leakcanary.HeapAnalysisJob.Result.Done
import leakcanary.ScreenOffTrigger

class ReleaseExampleApplication : ExampleApplication() {

  override fun onCreate() {
    super.onCreate()

    // Delete any remaining heap dump (if we crashed)
    analysisExecutor.execute {
      analysisClient.deleteHeapDumpFiles()
    }

    // Starts heap analysis on background importance
    BackgroundTrigger(
      application = this,
      analysisClient = analysisClient,
      analysisExecutor = analysisExecutor,
      analysisCallback = analysisCallback
    ).start()

    // Starts heap analysis when screen off
    ScreenOffTrigger(
      application = this,
      analysisClient = analysisClient,
      analysisExecutor = analysisExecutor,
      analysisCallback = analysisCallback
    ).start()
  }

  /**
   * Call this to trigger heap analysis manually, e.g. from
   * a help button.
   *
   * This method returns a `HeapAnalysisJob` on which you can
   * call `HeapAnalysisJob.cancel()` at any time.
   */
  fun triggerHeapAnalysisNow(): HeapAnalysisJob {
    val job = analysisClient.newJob()
    analysisExecutor.execute {
      val result = job.execute()
      analysisCallback(result)
    }
    return job
  }

  private val analysisClient by lazy {
    HeapAnalysisClient(
      // Use private app storage. cacheDir is never backed up which is important.
      heapDumpDirectoryProvider = { cacheDir },
      // stripHeapDump: remove all user data from hprof before analysis.
      config = HeapAnalysisConfig(stripHeapDump = true),
      // Default interceptors may cancel analysis for several other reasons.
      interceptors = listOf(flagInterceptor) + HeapAnalysisClient.defaultInterceptors(this)
    )
  }

  // Cancels heap analysis if "heap_analysis_flag" is false.
  private val flagInterceptor = object : HeapAnalysisInterceptor {
    val remoteConfig by lazy { FirebaseRemoteConfig.getInstance() }

    override fun intercept(chain: Chain): HeapAnalysisJob.Result {
      if (remoteConfig.getBoolean("heap_analysis_flag")) {
        chain.job.cancel("heap_analysis_flag false")
      }
      return chain.proceed()
    }
  }

  private val analysisExecutor = Executors.newSingleThreadExecutor { 
    thread(start = false, name = "Heap analysis executor") {
      android.os.Process.setThreadPriority(THREAD_PRIORITY_BACKGROUND)
      it.run()
    }
  }

  private val analysisCallback: (HeapAnalysisJob.Result) -> Unit = { result ->
    if (result is Done) {
      uploader.upload(result.analysis)
    }
  }

  private val uploader by lazy {
    BugsnagLeakUploader(this@ReleaseExampleApplication)
  }
}
```

--------------------------------

### JVM JUnit Test for Heap Growth Detection

Source: https://github.com/square/leakcanary/blob/main/docs/changelog.md

An example of a JUnit test that uses HeapDiff to detect heap growth. The test adds elements to a list repeatedly and asserts that no objects are growing in the heap.

```kotlin
class MyUnitTest {
  val detector = HeapDiff.repeatingJvmInProcessScenario()

  val growingList = mutableListOf<String>()

  @Test
  fun failing_test() {
    // Runs repeatedly until the heap stops growing or we reach max heap dumps.
    val heapDiff = detector.findRepeatedlyGrowingObjects {
      growingList += "Hi at ${System.currentTimeMillis()}"
    }

    // This should fail.
    assertThat(heapDiff.growingObjects).isEmpty()
  }
}
```

--------------------------------

### Shark CLI Usage Instructions

Source: https://github.com/square/leakcanary/blob/main/docs/shark.md

View the general usage instructions and available commands for the Shark CLI. This includes options for specifying devices, processes, and output verbosity.

```bash
$ shark-cli

Usage: shark-cli [OPTIONS] COMMAND [ARGS]...

                   ^`.                 .=""=.
   ^_
   \ \
   {  \
   {   \___----~~'              `~~-_/'-=\/=-'\,
    \                         /// a  `~.      \ \
    / /~~~~-, ,__.    ,      ///  __,,,,)      \ |
    \/      \/    `~~~;   ,---~~-_`/ \        / \/
                     /   /            '.    .'
                    '._.'             _|`~~`|_
                                      /|\  /|\

Options:
  -p, --process TEXT              Full or partial name of a process, e.g.
                                  "example" would match "com.example.app"
  -d, --device ID                 device/emulator id
  -m, --obfuscation-mapping PATH  path to obfuscation mapping file
  --verbose / --no-verbose        provide additional details as to what
                                  shark-cli is doing
  -h, --hprof FILE                path to a .hprof file
  --help                          Show this message and exit

Commands:
  interactive   Explore a heap dump.
  analyze       Analyze a heap dump.
  dump-process  Dump the heap and pull the hprof file.
  strip-hprof   Replace all primitive arrays from the provided heap dump with
                arrays of zeroes and generate a new "-stripped.hprof" file.

```

--------------------------------

### Generate API Docs and Deploy Documentation Site

Source: https://github.com/square/leakcanary/blob/main/docs/releasing.md

Cleans the docs/api directory, generates API documentation using Dokka, activates the virtual environment, and deploys the documentation site using MkDocs.

```bash
rm -rf docs/api && ./gradlew siteDokka && \
source venv/bin/activate && \
mkdocs gh-deploy
```

--------------------------------

### Shark CLI Help

Source: https://github.com/square/leakcanary/blob/main/docs/changelog.md

Displays the usage and available commands for the Shark CLI tool. Use this to understand the available options for process, device, and file path arguments.

```bash
$ shark-cli
Usage: shark-cli [OPTIONS] COMMAND [ARGS]...

                 ^`.                 .=""=.
 ^_              \  \               / _  _ \
 \ \             {   \             |  d  b  |
 {  \           /     `~~~--__     \   /\   /
 {   \___----~~'              `~~-_/'-=\/=-'\,
  \                         /// a  `~.      \ \
  / /~~~~-, ,__.    ,      ///  __,,,,)      \ |
  \/      \/    `~~~;   ,---~~-_`/ \        / \/
                   /   /            '.    .'
                  '._.'             _|`~~`|_
                                    /|\  /|\

Options:
  -p, --process NAME              Full or partial name of a process, e.g.
                                  "example" would match "com.example.app"
  -d, --device ID                 device/emulator id
  -m, --obfuscation-mapping PATH  path to obfuscation mapping file
  --verbose / --no-verbose        provide additional details as to what
                                  shark-cli is doing
  -h, --hprof FILE                path to a .hprof file
  --help                          Show this message and exit

Commands:
  interactive   Explore a heap dump.
  analyze       Analyze a heap dump.
  dump-process  Dump the heap and pull the hprof file.
  strip-hprof   Replace all primitive arrays from the provided heap dump with
                arrays of zeroes and generate a new "-stripped.hprof" file.

```

--------------------------------

### Check Local Docs Deployment

Source: https://github.com/square/leakcanary/wiki/Making-a-new-LeakCanary-release

Serve the MkDocs documentation locally to preview changes before deploying them.

```bash
mkdocs serve
```

--------------------------------

### Build Shark-CLI and Create GitHub Release

Source: https://github.com/square/leakcanary/blob/main/docs/releasing.md

Builds the shark-cli distribution zip and creates a GitHub release with the specified version and distribution file.

```bash
./gradlew shark:shark-cli:distZip && \
gh release create v$NEW_VERSION ./shark/shark-cli/build/distributions/shark-cli-$NEW_VERSION.zip --title v$NEW_VERSION --notes 'See [Change Log](https://square.github.io/leakcanary/changelog)'
```

--------------------------------

### Example LeakCanary NoLeakAssertionFailedError

Source: https://github.com/square/leakcanary/blob/main/docs/ui-tests.md

This is an example of the error output when LeakCanary detects application memory leaks during a UI test. It details the detected leaks, including the retained instances and their references.

```text
leakcanary.NoLeakAssertionFailedError: Application memory leaks were detected:
====================================
HEAP ANALYSIS RESULT
====================================
1 APPLICATION LEAKS

┬───
│ GC Root: System class
│
├─ com.example.MySingleton class
│    Leaking: NO (a class is never leaking)
│    ↓ static MySingleton.leakedView
│                         ~~~~~~~~~~
├─ android.widget.TextView instance
│    Leaking: YES (View.mContext references a destroyed activity)
│    ↓ TextView.mContext
╰→ com.example.MainActivity instance
     Leaking: YES (Activity#mDestroyed is true)
====================================
  at leakcanary.AndroidDetectLeaksAssert.assertNoLeaks(AndroidDetectLeaksAssert.kt:34)
  at leakcanary.LeakAssertions.assertNoLeaks(LeakAssertions.kt:21)
  at com.example.CartTest.addItemToCart(TuPeuxPasTest.kt:41)
```

--------------------------------

### Run Heap Growth Analysis with Shark CLI

Source: https://github.com/square/leakcanary/blob/main/docs/changelog.md

Command to execute heap growth analysis using the Shark CLI tool. Ensure you have downloaded and unzipped the Shark CLI.

```bash
$ ~/Downloads/shark-cli-3.0-alpha-2/bin/shark-cli -p com.example.app.debug heap-growth
```

--------------------------------

### Run Heap Growth Analysis with Shark CLI

Source: https://github.com/square/leakcanary/blob/main/docs/changelog.md

Execute the heap-growth command using the Shark CLI to analyze heap growth. This command requires the application's package name.

```bash
$ ~/Downloads/shark-cli-3.0-alpha-7/bin/shark-cli -p com.example.app.debug heap-growth
```

--------------------------------

### Deploy Docs to GitHub Pages

Source: https://github.com/square/leakcanary/wiki/Making-a-new-LeakCanary-release

Deploy the MkDocs documentation to GitHub Pages.

```bash
mkdocs gh-deploy
```

--------------------------------

### Shark CLI Interactive Mode Help

Source: https://github.com/square/leakcanary/blob/main/docs/changelog.md

Shows the available commands within the interactive heap dump exploration mode. Use this to navigate and query heap dumps directly from the command line.

```bash
$ shark-cli -h heapdump.hprof interactive
Enter command [help]:
help

Available commands:
  analyze                   Analyze the heap dump.
  class NAME@ID             Show class with a matching NAME and Object ID.
  instance CLASS_NAME@ID    Show instance with a matching CLASS_NAME and Object
ID.
  array CLASS_NAME@ID       Show array instance with a matching CLASS_NAME and
Object ID.
  ->instance CLASS_NAME@ID  Show path from GC Roots to instance.
  ~>instance CLASS_NAME@ID  Show path from GC Roots to instance, highlighting
suspect references.
  help                      Show this message.
  exit                      Exit this interactive prompt.

```

--------------------------------

### Retrieve ObjectWatcher (LeakCanary 2.0)

Source: https://github.com/square/leakcanary/blob/main/docs/upgrading-to-leakcanary-2.0.md

In LeakCanary 2.0, use AppWatcher.objectWatcher to get the ObjectWatcher instance.

```kotlin
val objectWatcher: ObjectWatcher = AppWatcher.objectWatcher
```

--------------------------------

### Create Release Branch and Set Version

Source: https://github.com/square/leakcanary/blob/main/docs/releasing.md

Checks out the main branch, pulls the latest changes, creates a new release branch, and updates the VERSION_NAME in gradle.properties.

```bash
git checkout main && git pull && \
git checkout -b release_$NEW_VERSION && \
sed -i '' "s/VERSION_NAME=.*/VERSION_NAME=$NEW_VERSION/" gradle.properties
```

--------------------------------

### Configure AppWatcher

Source: https://github.com/square/leakcanary/blob/main/docs/recipes.md

Customize LeakCanary's default configuration by modifying AppWatcher.config. This example disables watching Fragment views.

```kotlin
class DebugExampleApplication : ExampleApplication() {

  override fun onCreate() {
    super.onCreate() 
    AppWatcher.config = AppWatcher.config.copy(watchFragmentViews = false)
  }
}
```

--------------------------------

### Create Synthetic Heap Dumps for Testing

Source: https://github.com/square/leakcanary/blob/main/docs/dev-env.md

Programmatically create synthetic heap dumps for testing heap analysis functionality. Requires `testImplementation(projects.shark.sharkHprofTest)`.

```kotlin
val heapDump = dump {
  "com.example.MyClass" watchedInstance {
    field["fieldName"] = BooleanHolder(true)
  }
}
```

--------------------------------

### Perform Clean Build

Source: https://github.com/square/leakcanary/wiki/Making-a-new-LeakCanary-release

Execute a clean build of the project to ensure all artifacts are generated correctly.

```bash
./gradlew clean build
```

--------------------------------

### Generate Dokka Documentation

Source: https://github.com/square/leakcanary/wiki/Making-a-new-LeakCanary-release

Clean the existing documentation directory and then generate new Dokka documentation for all relevant modules.

```bash
rm -rf docs/api
./gradlew shark:dokka shark-android:dokka leakcanary-android-core:dokka leakcanary-android-instrumentation:dokka leakcanary-android-process:dokka shark-graph:dokka shark-hprof:dokka leakcanary-object-watcher-android:dokka shark-log:dokka leakcanary-object-watcher:dokka
```

--------------------------------

### Merge Back to Main and Prepare Next Development Iteration

Source: https://github.com/square/leakcanary/blob/main/docs/releasing.md

Merges the release branch back into main, updates gradle.properties to the next development version with a -SNAPSHOT suffix, and pushes the changes.

```bash
git checkout main && git pull && \
git merge --no-ff --no-edit release_$NEW_VERSION && \
sed -i '' "s/VERSION_NAME=.*/VERSION_NAME=$NEXT_VERSION-SNAPSHOT/" gradle.properties && \
git commit -am "Prepare for next development iteration" && \
git push
```

--------------------------------

### Analyze a Process on a Connected Device

Source: https://github.com/square/leakcanary/blob/main/docs/shark.md

Analyze the heap of a specific app process running on a connected Android device or emulator. Ensure the device is connected and the process is running.

```bash
$ shark-cli --device emulator-5554 --process com.example.app.debug analyze
```

--------------------------------

### Search for Old Version in Docs

Source: https://github.com/square/leakcanary/wiki/Making-a-new-LeakCanary-release

Use grep to find all occurrences of a specific version string within the documentation files.

```bash
grep -R "2.0-beta-3" ./docs
```

--------------------------------

### Configure ObjectWatcher for JVM

Source: https://github.com/square/leakcanary/blob/main/docs/recipes.md

Sets up the ObjectWatcher with a scheduled executor for delayed checks and registers a JvmHeapAnalyzer to listen for retained objects. Objects are watched for 5 seconds.

```kotlin
val scheduledExecutor = Executors.newSingleThreadScheduledExecutor()
val objectWatcher = ObjectWatcher(
    clock = Clock {
      System.currentTimeMillis()
    },
    checkRetainedExecutor = Executor { command ->
      scheduledExecutor.schedule(command, 5, SECONDS)
    }
)

val heapAnalyzer = JvmHeapAnalyzer(objectWatcher)
objectWatcher.addOnObjectRetainedListener(heapAnalyzer)
```

--------------------------------

### Set Release Version Variables

Source: https://github.com/square/leakcanary/blob/main/docs/releasing.md

Sets the new version and next development version variables. Prompts the user for input and determines the previous release tag.

```bash
echo "Current: $(grep VERSION_NAME gradle.properties)"
printf "Version being released (e.g. 3.0-alpha-9): " && read NEW_VERSION
printf "Next version, WITHOUT -SNAPSHOT (e.g. 3.0-alpha-10): " && read NEXT_VERSION
# Previous release tag, used for the changelog diff link:
PREV_VERSION=$(git tag --sort=-v:refname | head -1)
echo "Releasing $NEW_VERSION (previous: $PREV_VERSION), next dev version: $NEXT_VERSION-SNAPSHOT"
```

--------------------------------

### Configure Sonatype Snapshots Repository

Source: https://github.com/square/leakcanary/blob/main/docs/faq.md

Add Sonatype's snapshots repository to your project's repositories block to fetch SNAPSHOT versions of libraries.

```gradle
repositories {
  mavenCentral()
  maven {
    url 'https://s01.oss.sonatype.org/content/repositories/snapshots/'
  }
}
```

--------------------------------

### Detect Heap Growth with Espresso

Source: https://github.com/square/leakcanary/blob/main/docs/changelog.md

Use this snippet within an Espresso test to detect repeated heap growth. It runs a scenario in a loop until the heap stops growing or a maximum number of heap dumps is reached.

```kotlin
class MyEspressoTest {

  @Test
  fun greeter_says_hello_does_not_leak() {
    // Runs in a loop until the heap stops growing or we reach max heap dumps.
    val heapTraversal = HeapGrowthDetector.detectRepeatedHeapGrowth {
      // Runs repeatedly until the heap stops growing or we reach maxHeapDumps.
      onView(withId(R.id.name_field)).perform(typeText("Steve"))
      onView(withId(R.id.greet_button)).perform(click())
      onView(withText("Hello Steve!")).check(matches(isDisplayed()))
    }

    assertThat(heapTraversal.growingNodes).isEmpty()
  }
}
```

--------------------------------

### Verify LeakCanary Startup

Source: https://github.com/square/leakcanary/blob/main/docs/getting_started.md

Confirm LeakCanary is running by filtering on the 'LeakCanary' tag in Logcat. This message indicates LeakCanary is active and ready to detect leaks.

```logcat
D LeakCanary: LeakCanary is running and ready to detect leaks
```

--------------------------------

### Add LeakCanary instrumentation dependency

Source: https://github.com/square/leakcanary/blob/main/docs/ui-tests.md

Include the LeakCanary instrumentation artifact for UI tests and the main LeakCanary artifact for your app. This setup enables automatic leak detection during your instrumentation tests.

```groovy
androidTestImplementation 'com.squareup.leakcanary:leakcanary-android-instrumentation:{{ leak_canary.release }}'
// You still need to include the LeakCanary artifact in your app:
debugImplementation 'com.squareup.leakcanary:leakcanary-android:{{ leak_canary.release }}'
```

--------------------------------

### Configure LeakCanary: Disable Heap Dumps

Source: https://github.com/square/leakcanary/blob/main/docs/upgrading-to-leakcanary-2.0.md

LeakCanary's heap dump functionality can be controlled via LeakCanary.config. This example shows how to disable heap dumps by setting dumpHeap to false.

```kotlin
disableLeakCanaryButton.setOnClickListener {
  LeakCanary.config = LeakCanary.config.copy(dumpHeap = false)
}
```

--------------------------------

### Publish LeakCanary locally using Gradle

Source: https://github.com/square/leakcanary/blob/main/docs/releasing.md

Demonstrates how to publish LeakCanary locally using Gradle. This is normally unnecessary and requires setting specific Gradle properties for authentication and signing.

```bash
./gradlew publish
```

--------------------------------

### Run Normal UI Tests

Source: https://github.com/square/leakcanary/wiki/OSS-Dev-Environment

Execute the connected check for the leakcanary-support-fragment module for standard UI testing.

```bash
Normal UI tests: "./gradlew leakcanary-support-fragment:connectedCheck"

```

--------------------------------

### Configure Object Inspectors in LeakCanary

Source: https://github.com/square/leakcanary/blob/main/docs/recipes.md

Use ObjectInspectors to add custom logic for identifying leaking objects. This example shows how to label objects based on their properties and inspect specific view models.

```kotlin
class DebugExampleApplication : ExampleApplication() {

  override fun onCreate() {
    super.onCreate()
    val addEntityIdLabel = ObjectInspector { reporter ->
      reporter.whenInstanceOf("com.example.DbEntity") { instance ->
		val databaseIdField = instance["com.example.DbEntity", "databaseId"]!!
		val databaseId = databaseIdField.value.asInt!!
        labels += "DbEntity.databaseId = $databaseId"
      }
    }

    val singletonsInspector = 
      AppSingletonInspector("com.example.MySingleton", "com.example.OtherSingleton")

    val mmvmInspector = ObjectInspector { reporter ->
      reporter.whenInstanceOf("com.mmvm.SomeViewModel") { instance ->
        val destroyedField = instance["com.mmvm.SomeViewModel", "destroyed"]!!
        if (destroyedField.value.asBoolean!!) {
          leakingReasons += "SomeViewModel.destroyed is true"
        } else {
          notLeakingReasons += "SomeViewModel.destroyed is false"
        }
      }
    }

    LeakCanary.config = LeakCanary.config.copy(
        objectInspectors = AndroidObjectInspectors.appDefaults +
            listOf(addObjectIdLabel, singletonsInspector, mmvmInspector)
    )
  }
}
```

--------------------------------

### Upload Artifacts to Nexus

Source: https://github.com/square/leakcanary/wiki/Making-a-new-LeakCanary-release

Upload the built artifacts to the Sonatype OSS Nexus repository using the Gradle uploadArchives task.

```bash
./gradlew uploadArchives --no-daemon --no-parallel
```

--------------------------------

### Example of Bad Android Code Causing a Leak

Source: https://github.com/square/leakcanary/blob/main/docs/fundamentals-fixing-a-memory-leak.md

This Kotlin code demonstrates a common Android memory leak where an Activity's View is added to a static list in the Application class, preventing the Activity from being garbage collected.

```kotlin
class ExampleApplication : Application() {
  val leakedViews = mutableListOf<View>()
}

class MainActivity : Activity() {
  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.main_activity)

	val textView = findViewById<View>(R.id.helper_text)

    val app = application as ExampleApplication
	// This creates a leak, What a Terrible Failure!
	app.leakedViews.add(textView)
  }
}
```

--------------------------------

### Match Known Library Leaks with Custom Reference Matchers

Source: https://github.com/square/leakcanary/blob/main/docs/recipes.md

Extend LeakCanary's reference matching to identify specific library leaks. This example shows how to add a custom matcher for a singleton leaking a context, with conditions based on manufacturer and SDK version.

```kotlin
class DebugExampleApplication : ExampleApplication() {

  override fun onCreate() {
    super.onCreate()
    LeakCanary.config = LeakCanary.config.copy(
        referenceMatchers = AndroidReferenceMatchers.appDefaults +
            AndroidReferenceMatchers.staticFieldLeak(
                className = "com.samsing.SomeSingleton",
                fieldName = "sContext",
                description = "SomeSingleton has a static field leaking a context.",
                patternApplies = {
                  manufacturer == "Samsing" && sdkInt == 26
                }
            )
    )
  }
}
```

--------------------------------

### Update Mkdocs Configuration

Source: https://github.com/square/leakcanary/blob/main/docs/releasing.md

Updates the 'next_release' version in mkdocs.yml. The 'release' version is only updated for stable releases.

```bash
sed -i '' "s/next_release: .*/next_release: '$NEXT_VERSION'/" mkdocs.yml
# Stable releases ONLY — also promote the stable version:
# sed -i '' "s/release: .*/release: '$NEW_VERSION'/" mkdocs.yml
```

--------------------------------

### Read String Records from Hprof File

Source: https://github.com/square/leakcanary/blob/main/docs/shark.md

This Kotlin code snippet shows how to open an Hprof file and print all string records using Shark's Hprof reader.

```kotlin
import java.io.File
import shark.Hprof
import shark.HprofRecord.StringRecord
import shark.OnHprofRecordListener

fun main(args: Array<String>) {
  val heapDumpFile = File(args[0])

  // Prints all class and field names
  Hprof.open(heapDumpFile).use { hprof ->
    hprof.reader.readHprofRecords(
      recordTypes = setOf(StringRecord::class),
      listener = 
        OnHprofRecordListener { position, record -> println((record as StringRecord).string) },
    )
  }
}
```

--------------------------------

### Update Changelog

Source: https://github.com/square/leakcanary/blob/main/docs/releasing.md

Opens the changelog file for manual editing. Renames the 'Unreleased' section and adds a diff link.

```bash
"${EDITOR:-vi}" docs/changelog.md
```