> For the complete documentation index, see [llms.txt](https://docs.mburger.cloud/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.mburger.cloud/android-docs/fetch-for-blocks.md).

# Fetch for blocks

You should use **`MBurgerTasks`** static methods to retrieve data from MBurger dashboard.

This class has public static functions that will call asynchronously MBurger API. 

You have 2 ways to retrieve data from API:

* Listener
* Actions

## Listener

{% hint style="success" %}
The **Listener** approach is the easiest one. 
{% endhint %}

With every method of the MBurgerTasks class you should pass the corresponding listener to return data from the function to your control. 

{% hint style="info" %}
All the listeners are inside the **`MBApiResultsListeners`** and all of them are simple interfaces that will return the MBurger object you asked for or an error message. 
{% endhint %}

For example, you should use a **`MBApiProjectResultListener`** (implementing it to your Activity or Fragment or creating a new one runtime) to obtain Project basic data, so the class will implement these methods:

```kotlin
@Override
fun onProjectApiResult(project: MBProject) {
    /*API call went well*/
}

@Override
fun onProjectApiError(error: String) {
    /*There was an error, you should show it*/
}
```

## Actions

{% hint style="success" %}
The **Action** approach is more complicated but more flexible. 
{% endhint %}

It uses **`LocalBroadcastMessages`** to send data from the API to your Activity/Fragment using an Action which your Activity/Fragment is listening to. 

You can also use this method also if you are doing your own API calls to your server. First you must implement **`MBGenericApiResultListener`** which will automatically implement the method.Java

```kotlin
@Override
fun onApiResult(response: MBAPIResponse) {        
}
```

For example, to obtain the blocks and the project you have to follow these few steps:

* **Create** a `BroadcastReceiver`.
* **Initialize** the BroadcastReceiver in your onResume method with the `MBurgerApiActionInitializer` class specific function.
* **Pause** the BroadcastReceiver in your onPause method with the `MBurgerApiActionInitializer` class specific function.
* **Call** the task to send the blocks’ request according to the parameters given in this sample.
* **Fetch** the blocks from the response variable of `onApiResult`.

The code will result:

```kotlin
override fun onResume() {
    super.onResume();
    val actions  = arrayOf(MBAPIConstants.ACTION_GET_BLOCKS, MBAPIConstants.ACTION_GET_PROJECT)
    bRec = MBurgerApiActionInitializer.initializeNookoReceiverCustom(this, this, actions)
    MBurgerTasks.askForProject(this)

    /**Add custom filters to the API call or leave it null**/
    val arrayOfFilters: ArrayList<Any> = null

    /**Inside the blocks returned the “sections” field will be valorized**/
    val getSections = true

    /**Inside the sections the “elements” field will not be valorized (null)**/
    val getElements = false
    MBurgerTasks.askForBlocks(this, arrayOfFilters, getSections, getElements)
    MBurgerTasks.askForProject(this)
}

override fun onPause() {
    super.onPause()
    MBurgerApiActionInitializer.pauseNookoReceiver(this, bRec)
}

override fun onApiResult(MBAPIResponse response) {
/** Check ApiAction to distinguish the responses**/
    if (response.getApiAction().equals(MBAPIConstants.ACTION_GET_BLOCKS)) {
        if (response.getResult()) {
        blocks = (ArrayList<MBBlock>)response.getPayload().get(MBApiPayloadKeys.key_blocks)
        /** Once you received the project’s blocks you can draw your menu**/
        } else {
                Log.e(“ERROR RESPONSE API”, “THERE WAS AN ERROR DURING BLOCKS’ LOADING”)
            }
    }

    if(response.getApiAction().equals(MBAPIConstants.ACTION_GET_PROJECT)){
        if (response.getResult()) {
        project = (MBProject)response.getPayload().get(MBApiPayloadKeys.key_project)
        /** Your code**/
        } else {
                Log.e(“ERROR RESPONSE API”, “THERE WAS AN ERROR DURING BLOCKS’ LOADING”)
            }
    }
}
```

Note that you can check the ApiAction to distinguish the different responses, and you will find all responses inside the **`MBAPIConstants`** class.

{% hint style="info" %}
In case you previously initialized a BroadcastReceiver only for blocks this check is useless.
{% endhint %}

This is an example of a single-action BroadcastReceiver initialization (for blocks)

Single action initializationJava

```kotlin
override fun onResume() {
    super.onResume();
    bRec = MBurgerApiActionInitializer.initializeNookoReceiverForBlocks(this, this);
}
```