# 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);
}
```


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.mburger.cloud/android-docs/fetch-for-blocks.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.