### Handle Audio Processing Progress with Amplituda

Source: https://github.com/lincollincol/amplituda/blob/master/README.md

Illustrates how to implement a progress listener to monitor the audio processing steps in Amplituda. The listener provides callbacks for the start, stop, and step-by-step progress of operations like decoding, downloading, and processing.

```java
/**
 * AmplitudaProgressListener - progress listener class.
 * This class has 3 methods that describe current progress:
 *  - void onStartProgress() - amplituda start processing (optional)
 *  - void onStopProgress()  - amplituda stop processing (optional)
 *  - void onProgress(ProgressOperation operation, int progress) -
 *       amplituda process audio and share current operation and progress in percent (0-100)
 * onProgress() also inform about current operation:
 *  - PROCESSING  - amplituda start process audio
 *  - DECODING    - amplituda decode raw/res audio 
 *  - DOWNLOADING - amplituda download audio from url 
 */
amplituda.processAudio(
    <audio>,
    new AmplitudaProgressListener() {
        @Override
        public void onStartProgress() {
            super.onStartProgress();
            System.out.println("Start Progress");
        }

        @Override
        public void onStopProgress() {
            super.onStopProgress();
            System.out.println("Stop Progress");
        }

        @Override
        public void onProgress(ProgressOperation operation, int progress) {
            String currentOperation = "";
            switch (operation) {
                case PROCESSING: currentOperation = "Process audio"; break;
                case DECODING: currentOperation = "Decode resource"; break;
                case DOWNLOADING: currentOperation = "Download audio from url"; break;
            }
            System.out.printf("%s: %d%% %n", currentOperation, progress);
        }
    }
)
```

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

### Format Amplituda Results in Java

Source: https://github.com/lincollincol/amplituda/blob/master/README.md

Demonstrates various methods to format and retrieve results from AmplitudaResult in Java. It shows how to get results as a list, a list for a specific second, JSON, and different sequence formats (single-line, new-line, with custom delimiters).

```java
/**
 * Format result. As written earlier, AmplitudaResult
 * has many functions for formatting the result
 */
 AmplitudaResult<T> result;
 
 // Get result as list:
 List<Integer> samples = result.amplitudesAsList(); 
 System.out.println(Arrays.toString(samples.toArray()));
 // Output: [0, 0, 0, 0, 0, 5, 3, 6, . . . , 6, 4, 7, 1, 0, 0, 0]
 
 // Get result as list only for second `1`
 List<Integer> samplesForFirstSecond = result.amplitudesForSecond(1);
 System.out.println(Arrays.toString(samples.toArray()));
 // Output: [0, 0, 5, . . . 6, 4, 0]

// Get result as json format String
System.out.println(result.amplitudesAsJson());
// Output: [0, 0, 0, 0, 0, 5, 3, 6, . . . , 6, 4, 7, 1, 0, 0, 0]

// Get result as single line sequence format String (horizontal String)
System.out.println(result.amplitudesAsSequence(
        AmplitudaResult.SequenceFormat.SINGLE_LINE)
);
// Output: 0 0 0 0 0 5 3 6 . . . 6 4 7 1 0 0 0

// Get result as single line sequence format String with custom delimiter `*` (horizontal String)
System.out.println(result.amplitudesAsSequence(
        AmplitudaResult.SequenceFormat.SINGLE_LINE, " * ")
);
// Output: 0 * 0 * 0 * 0 * 0 * 5 * 3 * 6 * . . . 6 * 4 * 7 * 1 * 0 * 0 * 0

// Get result as new line sequence format String  
System.out.println(result.amplitudesAsSequence(
        AmplitudaResult.SequenceFormat.NEW_LINE)
);
/* Output: 
    0 
    0 
    5 
    3 
    . . . 
    6 
    1 
    0 
    0
    */
```

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

### Handling Audio Processing Progress

Source: https://github.com/lincollincol/amplituda/blob/master/README.md

This section explains how to use `AmplitudaProgressListener` to monitor the progress of audio processing. The listener provides callbacks for the start, stop, and current progress (including the operation type) of the processing task.

```APIDOC
## Handle Progress

### Description
Use the `AmplitudaProgressListener` interface to receive updates on the audio processing progress. This listener has methods for `onStartProgress`, `onStopProgress`, and `onProgress`, which reports the current operation (e.g., PROCESSING, DECODING, DOWNLOADING) and the progress percentage.

### Method
`amplituda.processAudio(audio, listener)`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **audio** (Object/String/Integer) - The audio data to process.
- **listener** (AmplitudaProgressListener) - An instance of the listener to receive progress updates.

### Request Example
```java
amplituda.processAudio(
    <audio>,
    new AmplitudaProgressListener() {
        @Override
        public void onStartProgress() {
            super.onStartProgress();
            System.out.println("Start Progress");
        }

        @Override
        public void onStopProgress() {
            super.onStopProgress();
            System.out.println("Stop Progress");
        }

        @Override
        public void onProgress(ProgressOperation operation, int progress) {
            String currentOperation = "";
            switch (operation) {
                case PROCESSING: currentOperation = "Process audio"; break;
                case DECODING: currentOperation = "Decode resource"; break;
                case DOWNLOADING: currentOperation = "Download audio from url"; break;
            }
            System.out.printf("%s: %d%% %n", currentOperation, progress);
        }
    }
)
```

### Response
No direct response, progress updates are delivered via callbacks to the provided listener.
```

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

### Handle Result and Errors with Amplituda

Source: https://github.com/lincollincol/amplituda/blob/master/README.md

Explains how to retrieve the processed audio results and handle potential errors using Amplituda. It details the `AmplitudaResult` and `AmplitudaProcessingOutput` classes and demonstrates various ways to use the `get()` method with success and error listeners.

```java
AmplitudaProcessingOutput<T> processingOutput;
// . . . process audio . . . 

/**
 * AmplitudaResult<T> - wrapper class for the final result
 * This class also provides many functions to format result: List<Integer>, String etc
 * and info about input audio: 
 *  - Input audio source: path to audio/resource or url. 
 *  - Source type according to input audio: FILE, PATH, URL or RESOURCE 
 *  - Audio duration
 * Generic type T - audio source type: File, String (URL or path), Integer (res/raw)
 */
 AmplitudaResult<T> result;
 
 /**
  * After processing you can get the result by calling the function get() 
  * This function has multiple overloads:
  *  - void get(successListener, errorListener)
  *  - void get(successListener)
  *  - AmplitudaResult<T> get(errorListener)
  *  - AmplitudaResult<T> get(successListener)
  */
 
// Overload #1: result as a callback with error listener
processingOutput.get(result -> { 
        /* handle result here */ 
    }, exception -> { 
        /* handle errors here */ 
    });

// Overload #2: result as a callback without error listener
processingOutput.get((AmplitudaSuccessListener<T>) result -> { 
    /* handle result here */ 
});

// Overload #3: result as a returned object with error listener
result = processingOutput.get((AmplitudaException exception) -> { 
    /* handle errors here */ 
});

// Overload #4: result as a returned object without error listener
result = processingOutput.get();

/**
 * Exceptions. More info about exceptions here:
 * https://github.com/lincollincol/Amplituda/tree/master/app/src/main/java/linc/com/amplituda/exceptions
 */
processingOutput.get((AmplitudaException exception) -> {
    if(exception instanceof AmplitudaIOException) {
        // Handle io exceptions
    } else if(exception instanceof AmplitudaProcessingException) {
        // Handle processing exceptions
    } else {
        exception.printStackTrace();
    }
});
```

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

### Process Audio from Multiple Input Sources

Source: https://context7.com/lincollincol/amplituda/llms.txt

Demonstrates processing audio from various input sources, including File objects, URLs, Android raw resources, InputStreams (useful for content URIs), and byte arrays. Each source is processed asynchronously, and a callback is provided to handle the results upon successful completion.

```java
import com.linc.amplituda.Amplituda;
import java.io.File;
import java.io.InputStream;

Amplituda amplituda = new Amplituda(context);

// Process from File object
File audioFile = new File("/storage/emulated/0/Music/song.mp3");
amplituda.processAudio(audioFile)
    .get(result -> {
        System.out.println("File processed: " + result.amplitudesAsList().size() + " samples");
    });

// Process from URL
amplituda.processAudio("https://example.com/audio.mp3")
    .get(result -> {
        System.out.println("URL audio processed: " + result.amplitudesAsList().size() + " samples");
    });

// Process from raw resource (res/raw folder)
amplituda.processAudio(R.raw.amplituda)
    .get(result -> {
        System.out.println("Resource audio processed: " + result.amplitudesAsList().size() + " samples");
    });

// Process from InputStream (e.g., content URI)
InputStream inputStream = getContentResolver().openInputStream(audioUri);
amplituda.processAudio(inputStream)
    .get(result -> {
        System.out.println("InputStream processed: " + result.amplitudesAsList().size() + " samples");
    });

// Process from byte array
byte[] audioBytes = loadAudioBytes();
amplituda.processAudio(audioBytes)
    .get(result -> {
        System.out.println("Byte array processed: " + result.amplitudesAsList().size() + " samples");
    });
```

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

### Initialize and Process Audio with Amplituda (Java)

Source: https://github.com/lincollincol/amplituda/blob/master/README.md

This snippet demonstrates the basic usage of the Amplituda library. It covers initializing the Amplituda object, processing an audio file from a given path, and handling the results or exceptions. The result object provides methods to access processed data like amplitudes, duration, and source information.

```java
/* Step 1: create Amplituda */
Amplituda amplituda = new Amplituda(context);

/* Step 2: process audio and handle result */
amplituda.processAudio("/storage/emulated/0/Music/Linc - Amplituda.mp3")
        .get(result -> {
            List<Integer> amplitudesData = result.amplitudesAsList();
            List<Integer> amplitudesForFirstSecond = result.amplitudesForSecond(1);
            long duration = result.getAudioDuration(AmplitudaResult.DurationUnit.SECONDS);
            String source = result.getAudioSource();
            InputAudio.Type sourceType = result.getInputAudioType();
            // etc
        }, exception -> {
            if(exception instanceof AmplitudaIOException) {
                System.out.println("IO Exception!");
            }
        });

/* And that's all! You can read full documentation below for more information about Amplituda features */
```

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

### Importing FFmpeg Shared Libraries with CMake

Source: https://github.com/lincollincol/amplituda/blob/master/amplituda/src/main/cpp/CMakeLists.txt

This snippet demonstrates how to import pre-built FFmpeg shared libraries (avutil, avformat, avcodec, swresample) into a CMake project. It specifies the shared library type, imported location, and associates them with the Android ABI. These imported libraries are then used for linking.

```cmake
cmake_minimum_required(VERSION 3.22.1)

project("Amplituda")

set(ffmpeg_DIR ${CMAKE_SOURCE_DIR}/ffmpeg)

include_directories(${ffmpeg_DIR}/${ANDROID_ABI}/include)

add_library(amplituda-avutil SHARED IMPORTED)
set_target_properties(amplituda-avutil PROPERTIES IMPORTED_LOCATION
        ${ffmpeg_DIR}/${ANDROID_ABI}/lib/libavutil-amplituda.so)

add_library(amplituda-avformat SHARED IMPORTED)
set_target_properties(amplituda-avformat PROPERTIES IMPORTED_LOCATION
        ${ffmpeg_DIR}/${ANDROID_ABI}/lib/libavformat-amplituda.so)

add_library(amplituda-avcodec SHARED IMPORTED)
set_target_properties(amplituda-avcodec PROPERTIES IMPORTED_LOCATION
        ${ffmpeg_DIR}/${ANDROID_ABI}/lib/libavcodec-amplituda.so)

add_library(amplituda-swresample SHARED IMPORTED)
set_target_properties(amplituda-swresample PROPERTIES IMPORTED_LOCATION
        ${ffmpeg_DIR}/${ANDROID_ABI}/lib/libswresample-amplituda.so)
```

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

### Java: Process Audio with Compression, Caching, and Progress Tracking

Source: https://context7.com/lincollincol/amplituda/llms.txt

This Java code snippet demonstrates how to use the Amplituda library to process an audio file. It includes configurations for compression, caching, and real-time progress updates via a listener. The processing is asynchronous, with success and error callbacks.

```java
import android.os.Bundle;
import android.util.Log;
import androidx.appcompat.app.AppCompatActivity;
import com.linc.amplituda.Amplituda;
import com.linc.amplituda.AmplitudaProgressListener;
import com.linc.amplituda.AmplitudaResult;
import com.linc.amplituda.Cache;
import com.linc.amplituda.Compress;
import com.linc.amplituda.ProgressOperation;
import java.util.Arrays;
import java.util.List;

public class AudioProcessorActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        // Initialize Amplituda
        Amplituda amplituda = new Amplituda(this);
        amplituda.setLogConfig(Log.ERROR, true);

        // Process audio with all features
        amplituda.processAudio(
            "/storage/emulated/0/Music/song.mp3",
            Compress.withParams(Compress.AVERAGE, 5),
            Cache.withParams(Cache.REUSE, "song-cache-key"),
            new AmplitudaProgressListener() {
                @Override
                public void onStartProgress() {
                    super.onStartProgress();
                    runOnUiThread(() -> showProgressBar());
                }

                @Override
                public void onStopProgress() {
                    super.onStopProgress();
                    runOnUiThread(() -> hideProgressBar());
                }

                @Override
                public void onProgress(ProgressOperation operation, int progress) {
                    String op = operation == ProgressOperation.PROCESSING ?
                        "Processing" : operation == ProgressOperation.DECODING ?
                        "Decoding" : "Downloading";
                    runOnUiThread(() -> updateProgress(op, progress));
                }
            }
        ).get(this::handleSuccess, this::handleError);
    }

    private void handleSuccess(AmplitudaResult<?> result) {
        // Get all amplitude data
        List<Integer> amplitudes = result.amplitudesAsList();

        // Get audio information
        long durationSeconds = result.getAudioDuration(AmplitudaResult.DurationUnit.SECONDS);
        long durationMillis = result.getAudioDuration(AmplitudaResult.DurationUnit.MILLIS);

        // Get formatted outputs
        String jsonOutput = result.amplitudesAsJson();
        String singleLineOutput = result.amplitudesAsSequence(
            AmplitudaResult.SequenceFormat.SINGLE_LINE
        );

        // Display results
        System.out.printf(
            "Duration: %d seconds (%d ms)%n" +
            "Total samples: %d%n" +
            "Amplitudes: %s%n" +
            "JSON format: %s%n",
            durationSeconds,
            durationMillis,
            amplitudes.size(),
            Arrays.toString(amplitudes.toArray()),
            jsonOutput
        );

        // Draw waveform using the amplitude data
        drawWaveform(amplitudes);
    }

    private void handleError(Throwable exception) {
        Log.e("Amplituda", "Processing failed", exception);
        showErrorDialog(exception.getMessage());
    }

    private void drawWaveform(List<Integer> amplitudes) {
        // Integrate with waveform visualization library
        // Use amplitudes as heights for waveform bars
    }

    private void showProgressBar() { /* UI update */ }
    private void hideProgressBar() { /* UI update */ }
    private void updateProgress(String operation, int progress) { /* UI update */ }
    private void showErrorDialog(String message) { /* UI update */ }
}

```

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

### Building and Linking Native C++ Library with CMake

Source: https://github.com/lincollincol/amplituda/blob/master/amplituda/src/main/cpp/CMakeLists.txt

This snippet defines a C++ shared library named 'amplituda-native-lib' from 'amplituda-native-lib.cpp'. It then links this native library with the imported FFmpeg shared libraries (avutil, avformat, avcodec, swresample) using target_link_libraries. This ensures that the native code can access the functionality provided by FFmpeg.

```cmake
add_library(amplituda-native-lib SHARED amplituda-native-lib.cpp)
set_target_properties(amplituda-native-lib PROPERTIES LINKER_LANGUAGE CXX)

target_link_libraries(
        amplituda-native-lib
        amplituda-avutil
        amplituda-avformat
        amplituda-avcodec
        amplituda-swresample
)
```

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

### Compress Amplituda Output Data (Java)

Source: https://github.com/lincollincol/amplituda/blob/master/README.md

This Java code demonstrates how to compress the output data from Amplituda processing. Compression is useful as audio files can generate a large number of samples. The `Compress.withParams` method allows you to specify the desired number of samples per second and the compression type (SKIP, PEEK, or AVERAGE) to reduce the data size.

```java
/** 
 * Compress result data (optional) 
 * The output data can contain a lot of samples. 
 * For example: 
 *  - 5-second audio can contain 100+ samples
 *  - 3-minute audio can contain 7000+ samples
 * You can pass `Compress` params with the number of 
 * preferred samples per second and compress type as a parameter.
 * Compress types:
 * - Compress.SKIP    - take first number of `preferredSamplesPerSecond` and skip others 
 * - Compress.PEEK    - take peek number of `preferredSamplesPerSecond` and skip others
 * - Compress.AVERAGE - merge all samples to number of `preferredSamplesPerSecond`
 */ 
 
// Example: input audio duration - 10 seconds
 
amplituda.processAudio(<audio>, Compress.withParams(Compress.AVERAGE, 1));
// Output: data with 1 sample per 1 second. 
// Approximate output data size - 60 [duration] * 1 [preferredSamplePerSecond] = 60 [samples]

amplituda.processAudio(<audio>, Compress.withParams(Compress.AVERAGE, 5));
// Output: data with 5 sample per 1 second
// Approximate output data size - 60 [duration] * 5 [preferredSamplePerSecond] = 300 [samples]
```

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

### Process Various Audio Sources with Amplituda (Java)

Source: https://github.com/lincollincol/amplituda/blob/master/README.md

This Java code illustrates how to use Amplituda to process audio from different sources, including local files, file paths, URLs, and Android resources. The `AmplitudaProcessingOutput` class acts as a wrapper for the processing results, and its generic type `T` can represent various audio source types.

```java
Amplituda amplituda = new Amplituda(context);

/**
 * AmplitudaProcessingOutput<T> - wrapper class for Amplituda processing result.
 * This class stores the output audio processing data
 * and provides functions to obtain the result
 * Generic type T - audio source type: File, String (URL or path), Integer (res/raw) 
 */
AmplitudaProcessingOutput<T> processingOutput;

/* Process audio */

// Local audio file
processingOutput = amplituda.processAudio(new File("/storage/emulated/0/Music/Linc - Amplituda.mp3"));

// Path to local audio file
processingOutput = amplituda.processAudio("/storage/emulated/0/Music/Linc - Amplituda.mp3");

// URL audio
processingOutput = amplituda.processAudio("https://audio-url-example.com/amplituda.mp3");

// Resource audio
processingOutput = amplituda.processAudio(R.raw.amplituda);
```

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

### Reduce App Size in Android Manifest

Source: https://github.com/lincollincol/amplituda/blob/master/README.md

Provides instructions on how to reduce the application size by setting `android:extractNativeLibs="false"` in the application tag within the AndroidManifest.xml file.

```xml
<application
      . . .
    android:extractNativeLibs="false"
      . . . >
    <activity . . ./>
</application>
```

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

### Process Audio from File Path with Error Handling

Source: https://context7.com/lincollincol/amplituda/llms.txt

Processes an audio file from a local file path and retrieves amplitude data. It includes comprehensive error handling for potential IO and processing exceptions. The result provides amplitudes as a list, audio duration, source information, and specific sample data for a given second.

```java
import com.linc.amplituda.Amplituda;
import com.linc.amplituda.AmplitudaResult;
import com.linc.amplituda.InputAudio;
import com.linc.amplituda.exceptions.AmplitudaIOException;
import com.linc.amplituda.exceptions.AmplitudaProcessingException;
import java.util.List;

Amplituda amplituda = new Amplituda(context);

// Process audio file from storage path
amplituda.processAudio("/storage/emulated/0/Music/Linc - Amplituda.mp3")
    .get(result -> {
        // Get amplitudes as list of integers
        List<Integer> amplitudesData = result.amplitudesAsList();

        // Get audio duration in seconds or milliseconds
        long durationSeconds = result.getAudioDuration(AmplitudaResult.DurationUnit.SECONDS);
        long durationMillis = result.getAudioDuration(AmplitudaResult.DurationUnit.MILLIS);

        // Get source information
        String source = (String) result.getAudioSource();
        InputAudio.Type sourceType = result.getInputAudioType();

        // Get amplitudes for specific second
        List<Integer> amplitudesForFirstSecond = result.amplitudesForSecond(1);

        System.out.println("Amplitudes: " + amplitudesData);
        System.out.println("Duration: " + durationSeconds + " seconds");
        System.out.println("First second samples: " + amplitudesForFirstSecond);
    }, exception -> {
        // Handle exceptions
        if(exception instanceof AmplitudaIOException) {
            System.err.println("IO Exception: " + exception.getMessage());
        } else if(exception instanceof AmplitudaProcessingException) {
            System.err.println("Processing Exception: " + exception.getMessage());
        } else {
            exception.printStackTrace();
        }
    });
```

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

### Compress Output Data

Source: https://context7.com/lincollincol/amplituda/llms.txt

Reduce the number of samples using compression to control data size for visualization. Supports SKIP, PEAK, and AVERAGE compression methods.

```APIDOC
## Compress Output Data

### Description
Reduce the number of samples using compression to control data size for visualization. Supports SKIP, PEAK, and AVERAGE compression methods.

### Method
Amplituda.processAudio(audioPath, Compress.withParams(...))

### Parameters
#### Compression Options
- **SKIP** (Integer) - Number of samples to take per second.
- **PEAK** (Integer) - Number of peak samples to take per second.
- **AVERAGE** (Integer) - Number of samples per second after merging.

### Request Example
```java
// SKIP compression
amplituda.processAudio(audioPath, Compress.withParams(Compress.SKIP, 5));

// PEAK compression
amplituda.processAudio(audioPath, Compress.withParams(Compress.PEAK, 10));

// AVERAGE compression
amplituda.processAudio(audioPath, Compress.withParams(Compress.AVERAGE, 1));
```

### Response
#### Success Response (200)
- **result** (AmplitudaResult) - Object containing processed amplitudes.

#### Response Example
```json
{
  "amplitudesAsList": "[sample_count]"
}
```
```

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

### Initialize Amplituda Android Context

Source: https://context7.com/lincollincol/amplituda/llms.txt

Initializes the Amplituda library with an Android application context, which is necessary before processing any audio files. Optionally, logging can be enabled for debugging purposes by configuring the log level and whether to show timestamps.

```java
import android.content.Context;
import com.linc.amplituda.Amplituda;

// Initialize Amplituda with application context
Context context = getApplicationContext();
Amplituda amplituda = new Amplituda(context);

// Optional: Enable logging for debugging
import android.util.Log;
amplituda.setLogConfig(Log.DEBUG, true);
```

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

### Cache Audio Output Data with Amplituda

Source: https://github.com/lincollincol/amplituda/blob/master/README.md

Demonstrates how to enable and manage caching for audio processing outputs in Amplituda. It covers reusing cached data, refreshing cache, setting custom cache keys, and clearing cache entries.

```java
/** 
 * Cache result data (optional)
 * Amplituda provides cache implementation. 
 * You can reuse already processed audio files. 
 * Cache states:
 * - Cache.REUSE   - use already cached data or write
 *                   processed data to cache (if cache data doesn't exist) 
 * - Cache.REFRESH - update existing cache data. 
 *                   WARNING: use this cache state, when you need to update existing cache data  
 * Key (optional)  - custom cache key. Should be unique for each audio.
 */ 

// Enable amplituda cache feature:
amplituda.processAudio(<audio>, Cache.withParams(Cache.REUSE));
// Cache with custom key. The key should be unique 
amplituda.processAudio(<audio>, Cache.withParams(Cache.REUSE, "my-unique-key"));

// Clear all cache data
amplituda.clearCache();
// Clear cache data for specific audio (if exist)
amplituda.clearCache(<audio>);
amplituda.clearCache("/storage/emulated/0/Music/Linc - Amplituda.mp3", false);
// Clear cache data by custom key. 
amplituda.clearCache("my-unique-key", true);
```

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

### Handling Processing Results and Errors

Source: https://github.com/lincollincol/amplituda/blob/master/README.md

This section details how to retrieve the results of audio processing using `AmplitudaProcessingOutput` and handle potential errors. It outlines different methods for obtaining the result, either through callbacks or as a returned object, and explains how to handle various exception types.

```APIDOC
## Handle Result and Errors

### Description
After processing audio with Amplituda, you can retrieve the results and handle any exceptions using the `AmplitudaProcessingOutput` class. The `get()` method provides multiple overloads to receive results via success and error listeners, or directly as a returned `AmplitudaResult` object. Specific exception types like `AmplitudaIOException` and `AmplitudaProcessingException` can be caught for targeted error handling.

### Method
`processingOutput.get(successListener, errorListener)`
`processingOutput.get(successListener)`
`processingOutput.get(errorListener)`
`processingOutput.get()`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None (Methods are called on an existing `AmplitudaProcessingOutput` object).

### Request Example
```java
// Overload #1: result as a callback with error listener
processingOutput.get(result -> { 
        /* handle result here */ 
    }, exception -> { 
        /* handle errors here */ 
    });

// Overload #2: result as a callback without error listener
processingOutput.get((AmplitudaSuccessListener<T>) result -> { 
    /* handle result here */ 
});

// Overload #3: result as a returned object with error listener
result = processingOutput.get((AmplitudaException exception) -> { 
    /* handle errors here */ 
});

// Overload #4: result as a returned object without error listener
result = processingOutput.get();

// Exception Handling Example:
processingOutput.get((AmplitudaException exception) -> {
    if(exception instanceof AmplitudaIOException) {
        // Handle io exceptions
    } else if(exception instanceof AmplitudaProcessingException) {
        // Handle processing exceptions
    } else {
        exception.printStackTrace();
    }
});
```

### Response
#### Success Response
- **AmplitudaResult<T>** - A wrapper object containing the processed audio data and information about the input audio (source, duration, etc.). The generic type `T` depends on the input audio source type (File, String, Integer).

#### Response Example
```json
{
  "result": "..."
}
```

#### Error Response
- **AmplitudaException** - An exception object detailing the error encountered during processing.
```

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

### Track Processing Progress

Source: https://context7.com/lincollincol/amplituda/llms.txt

Monitor audio processing progress with callback listeners for UI updates. Provides progress updates for decoding, downloading, and processing operations.

```APIDOC
## Track Processing Progress

### Description
Monitor audio processing progress with callback listeners for UI updates. Provides progress updates for decoding, downloading, and processing operations.

### Method
Amplituda.processAudio(urlOrPath, AmplitudaProgressListener)

### Parameters
#### Progress Listener Callbacks
- **onStartProgress()**: Called when processing begins.
- **onStopProgress()**: Called when processing completes.
- **onProgress(ProgressOperation operation, int progress)**: Called during processing with the current operation and progress percentage (0-100).

### Request Example
```java
amplituda.processAudio("https://example.com/audio.mp3", new AmplitudaProgressListener() {
    @Override
    public void onStartProgress() {
        // Update UI: show progress bar
        System.out.println("Processing started");
    }

    @Override
    public void onStopProgress() {
        // Update UI: hide progress bar
        System.out.println("Processing completed");
    }

    @Override
    public void onProgress(ProgressOperation operation, int progress) {
        // Update UI: show progress percentage
        System.out.printf("%s: %d%%\n", operation.name(), progress);
    }
});
```

### Response
#### Success Response (200)
- **result** (AmplitudaResult) - Object containing processed amplitudes.

#### Error Response
- **exception** (Exception) - Details about the processing error.

#### Response Example
```json
{
  "amplitudesAsList": "[sample_count]"
}
```
```

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

### Add Amplituda Dependency (Groovy)

Source: https://github.com/lincollincol/amplituda/blob/master/README.md

This code snippet shows how to add the Amplituda library as a dependency to your Android project using Gradle. It includes the necessary repository configuration and the dependency declaration for your `build.gradle` file.

```groovy
allprojects {
  repositories {
    maven { url 'https://jitpack.io' }
  }
}

dependencies {
  implementation 'com.github.lincollincol:amplituda:x.y.z'
}
```

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

### Compress Audio Output Data with Amplituda

Source: https://context7.com/lincollincol/amplituda/llms.txt

Reduces the number of audio samples for visualization by applying compression. Supports SKIP, PEAK, and AVERAGE modes, each with configurable sample rates. Ensure Amplituda library is initialized and audio path is valid.

```java
import com.linc.amplituda.Amplituda;
import com.linc.amplituda.Compress;

Amplituda amplituda = new Amplituda(context);
String audioPath = "/storage/emulated/0/Music/song.mp3";

// SKIP: Take first N samples per second, skip others
amplituda.processAudio(audioPath, Compress.withParams(Compress.SKIP, 5))
    .get(result -> {
        // For 60-second audio: approximately 60 * 5 = 300 samples
        System.out.println("SKIP compression: " + result.amplitudesAsList().size() + " samples");
    });

// PEAK: Take peak N samples per second, skip others
amplituda.processAudio(audioPath, Compress.withParams(Compress.PEAK, 10))
    .get(result -> {
        // For 60-second audio: approximately 60 * 10 = 600 samples
        System.out.println("PEAK compression: " + result.amplitudesAsList().size() + " samples");
    });

// AVERAGE: Merge all samples to N samples per second
amplituda.processAudio(audioPath, Compress.withParams(Compress.AVERAGE, 1))
    .get(result -> {
        // For 60-second audio: approximately 60 * 1 = 60 samples
        System.out.println("AVERAGE compression: " + result.amplitudesAsList().size() + " samples");
    });
```

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

### Track Audio Processing Progress with Amplituda

Source: https://context7.com/lincollincol/amplituda/llms.txt

Monitors the progress of audio processing operations, providing real-time updates via a listener. Useful for updating UI elements like progress bars. Requires initialization of the Amplituda library and a valid audio source (local path or URL). Handles different operations like decoding, downloading, and processing.

```java
import com.linc.amplituda.Amplituda;
import com.linc.amplituda.AmplitudaProgressListener;
import com.linc.amplituda.ProgressOperation;

Amplituda amplituda = new Amplituda(context);

amplituda.processAudio(
    "https://example.com/audio.mp3",
    new AmplitudaProgressListener() {
        @Override
        public void onStartProgress() {
            super.onStartProgress();
            // Update UI: show progress bar
            System.out.println("Processing started");
        }

        @Override
        public void onStopProgress() {
            super.onStopProgress();
            // Update UI: hide progress bar
            System.out.println("Processing completed");
        }

        @Override
        public void onProgress(ProgressOperation operation, int progress) {
            String currentOperation = "";
            switch (operation) {
                case PROCESSING:
                    currentOperation = "Processing audio";
                    break;
                case DECODING:
                    currentOperation = "Decoding resource";
                    break;
                case DOWNLOADING:
                    currentOperation = "Downloading from URL";
                    break;
            }
            // Update UI: show progress percentage (0-100)
            System.out.printf("%s: %d%%%n", currentOperation, progress);
        }
    }
).get(result -> {
    System.out.println("Success: " + result.amplitudesAsList().size() + " samples");
}, exception -> {
    System.err.println("Error: " + exception.getMessage());
});
```

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

### Audio Processing with Cache

Source: https://github.com/lincollincol/amplituda/blob/master/README.md

This section describes how to enable and manage caching for audio processing in Amplituda. Caching allows reusing previously processed audio files to improve performance. You can also clear cache data selectively or entirely.

```APIDOC
## Cache Output Data

### Description
Amplituda provides an optional cache implementation to reuse already processed audio files. You can control cache behavior using `Cache.REUSE` or `Cache.REFRESH` states, and optionally provide a custom unique key.

### Method
`amplituda.processAudio(audio, cacheParams)`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **audio** (Object/String/Integer) - The audio data to process.
- **cacheParams** (Object) - Cache parameters, e.g., `Cache.withParams(Cache.REUSE)` or `Cache.withParams(Cache.REUSE, "my-unique-key")`.

### Request Example
```java
// Enable amplituda cache feature:
amplituda.processAudio(<audio>, Cache.withParams(Cache.REUSE));
// Cache with custom key. The key should be unique 
amplituda.processAudio(<audio>, Cache.withParams(Cache.REUSE, "my-unique-key"));
```

### Response
No direct response for cache setup, but processed data will be cached.

### Cache Management

#### Clear All Cache Data
```java
amplituda.clearCache();
```

#### Clear Cache for Specific Audio
```java
amplituda.clearCache(<audio>);
amplituda.clearCache("/storage/emulated/0/Music/Linc - Amplituda.mp3", false);
```

#### Clear Cache by Custom Key
```java
amplituda.clearCache("my-unique-key", true);
```
```

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

### Cache Processed Audio Results with Amplituda

Source: https://context7.com/lincollincol/amplituda/llms.txt

Enables caching of audio processing results to improve performance by reusing existing data. Supports REUSE, REFRESH modes and custom cache keys. The Amplituda library must be initialized. Cache can be cleared globally or for specific audio files/keys.

```java
import com.linc.amplituda.Amplituda;
import com.linc.amplituda.Cache;

Amplituda amplituda = new Amplituda(context);
String audioPath = "/storage/emulated/0/Music/song.mp3";

// Enable cache with REUSE mode (use existing cache or create new)
amplituda.processAudio(audioPath, Cache.withParams(Cache.REUSE))
    .get(result -> {
        System.out.println("Processed with cache: " + result.amplitudesAsList().size() + " samples");
    });

// Cache with custom key for unique identification
amplituda.processAudio(audioPath, Cache.withParams(Cache.REUSE, "my-unique-key"))
    .get(result -> {
        System.out.println("Cached with custom key");
    });

// REFRESH mode: update existing cache data
amplituda.processAudio(audioPath, Cache.withParams(Cache.REFRESH))
    .get(result -> {
        System.out.println("Cache refreshed");
    });

// Clear all cache
amplituda.clearCache();

// Clear cache for specific audio
amplituda.clearCache(audioPath, false);

// Clear cache by custom key
amplituda.clearCache("my-unique-key", true);
```

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

### Configure Amplituda Logs in Java

Source: https://github.com/lincollincol/amplituda/blob/master/README.md

Shows how to enable or disable logging for Amplituda in Java. It initializes the Amplituda object and then uses `setLogConfig` to control the log level and whether logs are enabled. Amplituda logs are disabled by default.

```java
Amplituda amplituda = new Amplituda(context);

// Use default android Log constants to set priority. The second parameter - enable or disable logs. 
// Amplituda logs are disabled by default
amplituda.setLogConfig(Log.DEBUG, true);
```

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

### Cache Processing Results

Source: https://context7.com/lincollincol/amplituda/llms.txt

Enable caching to reuse already processed audio data and improve performance. Supports REUSE and REFRESH modes, custom cache keys, and clearing cache.

```APIDOC
## Cache Processing Results

### Description
Enable caching to reuse already processed audio data and improve performance. Supports REUSE and REFRESH modes, custom cache keys, and clearing cache.

### Method
Amplituda.processAudio(audioPath, Cache.withParams(...))
Amplituda.clearCache()
Amplituda.clearCache(audioPath, deleteFile)
Amplituda.clearCache(cacheKey, isKeyBased)

### Parameters
#### Cache Options
- **REUSE** (Enum) - Use existing cache or create new.
- **REFRESH** (Enum) - Update existing cache data.
- **customKey** (String) - A unique key for identifying cached data.
- **audioPath** (String) - Path to the audio file.
- **deleteFile** (Boolean) - Whether to delete the cache file when clearing.
- **isKeyBased** (Boolean) - Whether the cache is identified by a key.

### Request Example
```java
// Enable cache with REUSE mode
amplituda.processAudio(audioPath, Cache.withParams(Cache.REUSE));

// Cache with custom key
amplituda.processAudio(audioPath, Cache.withParams(Cache.REUSE, "my-unique-key"));

// REFRESH mode
amplituda.processAudio(audioPath, Cache.withParams(Cache.REFRESH));

// Clear all cache
amplituda.clearCache();

// Clear cache for specific audio
amplituda.clearCache(audioPath, false);

// Clear cache by custom key
amplituda.clearCache("my-unique-key", true);
```

### Response
#### Success Response (200)
- **result** (AmplitudaResult) - Object containing processed amplitudes (if cache was used or created).

#### Response Example
```json
{
  "amplitudesAsList": "[sample_count]"
}
```
```

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

### Add Permissions to Android Manifest

Source: https://github.com/lincollincol/amplituda/blob/master/README.md

Specifies the necessary permissions to be added to the AndroidManifest.xml file for the Amplituda project. These include storage and internet permissions, with special handling for Android 10+ regarding external storage.

```xml
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
<uses-permission android:name="android.permission.INTERNET" />

<!-- Android 10+ -->
<application
    android:requestLegacyExternalStorage="true">
    <activity . . ./>
</application>
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.