What Is Callback in Android

What is callback in Android?

Here is a nice tutorial, which describes callbacks and the use-case well.

The concept of callbacks is to inform a class synchronous / asynchronous if some work in another class is done. Some call it the Hollywood principle: "Don't call us we call you".

Here's a example:

class A implements ICallback {
     MyObject o;
     B b = new B(this, someParameter);

     @Override
     public void callback(MyObject o){
           this.o = o;
     }
}

class B {
     ICallback ic;
     B(ICallback ic, someParameter){
         this.ic = ic;
     }

    new Thread(new Runnable(){
         public void run(){
             // some calculation
             ic.callback(myObject)
         }
    }).start(); 
}

interface ICallback{
    public void callback(MyObject o);
}

Class A calls Class B to get some work done in a Thread. If the Thread finished the work, it will inform Class A over the callback and provide the results. So there is no need for polling or something. You will get the results as soon as they are available.

In Android Callbacks are used f.e. between Activities and Fragments. Because Fragments should be modular you can define a callback in the Fragment to call methods in the Activity.

How to Define Callbacks in Android?

In many cases, you have an interface and pass along an object that implements it. Dialogs for example have the OnClickListener.

Just as a random example:

// The callback interface
interface MyCallback {
    void callbackCall();
}

// The class that takes the callback
class Worker {
   MyCallback callback;

   void onEvent() {
      callback.callbackCall();
   }
}

// Option 1:

class Callback implements MyCallback {
   void callbackCall() {
      // callback code goes here
   }
}

worker.callback = new Callback();

// Option 2:

worker.callback = new MyCallback() {

   void callbackCall() {
      // callback code goes here
   }
};

I probably messed up the syntax in option 2. It's early.

Callback Method Android

Chris, Imagine that you have a function:

fun test() {
  ...
}

Then you decided to add some magic to it. For instance, add 'block' that could be done after function test finished its job. So, here we need to put some extra into code:

interface CallbackInterface {
  fun doJob()
}

and your function become:

fun test(block: CallbackInterface) {
  ...
  block.doJob()
}

so then you can call your test function like this (or pass CallbackInterface into test function):

test(object: CallbackInterface {
  override fun doJob() {
    ...
  }
})

In general, the point is to pass the interface as a parameter in function and call it whenever you want and do on another end do whatever you want with the results.

or in Kotlin you can do like this:

fun test(block: ()-> Unit) {
  ...
  block.invoke() // or just block()
}

and use it:

test {
  ...
}

How to realize a callback in android?

You can easily use an interface and handle the callback accordingly from your calling activity/class/other thread. Here is an example.

Define an interface like the following first.

public interface ThreadFinishListener {
    void onFinish();
}

Let us assume you are instantiating a Thread from an Activity. Hence implement the listener in your Activity like the following.

public class MainActivity extends AppCompatActivity implements ThreadFinishListener {
    // .... Other functions in your activity 

    @Override
    void onFinish() {
        // Do something when the Thread is finished and returned back to the activity
        // This is actually your callback function. 
    }
}

Now modify the constructor of your Thread class so that you can pass the listener to it.

public class MyThread extends Thread {
    private ThreadFinishListener listener; 

    public MyThread(ThreadFinishListener listener){
       this.listener = listener;
    }

    public void run(){
        //Do some stuff
        finish();
    }

    public void finish() {
        // This will invoke the function call in your activity
        listener.onFinish();
    }
}

Now while initializing your Thread, you might want to pass the listener to it as follows.

MyThread thread = new MyThread(this);
thread.run();

I hope that suffices.

What are callbacks and how do I implement them in Android?

Do you mean callback using interface?
if yes here's an example

this is callbackmenu.java

package com.example.test.callback;

public interface CallbackCalendar {
    public void onClick();
}

this is an example how you implement it

public class CallbackCell implements CallbackCalendar{

    @Override
    public void onClick() {
        Log.i("TAG", "IT WORKS!);
        addChild(2);
    }
}

this is an example that will allow you to access a view from another view
like what I use in my calendar library, I create 3 view classes, calendar View, calendar row, calendar cell

with passing this callback from calendar view to calendar cell we can add view,set value or anything else in the calendar view from the calendar cell (calendar cell is a part of calendar row and calendar row is a part of calendar view) in this example I'm trying to set whenever the user click the cell we will add another view in the calendar view (main view)

this is the example of using callback in the calendar cell

public CalendarCell(Context context,int day,final CallbackCalendar callback)
{
    super(context);
    final int temp = day;
    this.context = context;
    this.setBackgroundColor(Color.parseColor("#FFFFFFFF"));
    LinearLayout.LayoutParams lpCalendarCell = new LinearLayout.LayoutParams(LayoutParams.FILL_PARENT, LayoutParams.FILL_PARENT);
    lpCalendarCell.weight = 1;
    this.setLayoutParams(lpCalendarCell);
    this.setOnClickListener(new OnClickListener() {

        @Override
        public void onClick(View v) {
            callback.onClick();
        }
    });
    addContainer(day);
}

so I set the callback in the calendar view and pass it to the calendar row and pass it again to the calendar cell and call the onClick in the calendar cell

I think that's all if you have any question feel free to write in the comment :)

How to pass different callbacks to same function in android

I would like to recommend to have a separate interface class without keeping it inside of a Class or Activity.

So declare an interface like this. Create a separate file.

public interface VolleyCallback {
    void onSuccess(String result);
}

Then create a public instance of the VolleyCallback interface in your VolleyAPIService class like the following. Remove the parameter from the volleyPost method for cleaner implementation.

public class VolleyAPIService {

    public VolleyCallback callback; 

    public void volleyPost(String URL, Map<String, String> param, Context context) {
        RequestQueue requestQueue = Volley.newRequestQueue(context);
        final Map<String, String> params = param;

        StringRequest stringRequest = new StringRequest(Request.Method.POST, URL,
                new Response.Listener<String>() {
                    @Override
                    public void onResponse(String response) {
                        callback.onSuccess(response);
                    }
                },
                new Response.ErrorListener() {
                    @Override
                    public void onErrorResponse(VolleyError error) {
                    }
                }) {
            @Override
            protected Map<String, String> getParams() {;
                return params;
            }
        };
        requestQueue.add(stringRequest);
    }
}

Now from your MainActivity, implement the interface that you have created and override the callback function like the following.

public class MainActivity extends AppCompatActivity implements VolleyCallback {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        companyLogin("abc", "123");
    }
    public interface VolleyCallback {
        void onSuccess(String result);
    }

    public void companyLogin(String companyname, String password) {
        RequestQueue requestQueue = Volley.newRequestQueue(this);
        String URL = "http://...";
        final Map<String, String> params = new HashMap<String, String>();
        params.put("name", companyname);
        params.put("pwd", password);

        Intent volley_service = new Intent(MainActivity.this, VolleyAPIService.class);
        MainActivity.this.startService(volley_service);

        VolleyAPIService volleyAPIService = new VolleyAPIService();

        // Assign the callback here to listen the response from the API service.
        volleyAPIService.callback = this; 
        volleyAPIService.volleyPost(URL, params, MainActivity.this);
    }

    @Override
    public void onSuccess(String result) {
        // Handle the success or failure here
        if (!result.isEmpty()) {
            Intent userLoginActivity = new Intent(MainActivity.this, UserLogin.class);
            startActivity(userLoginActivity);
        } else {
            AlertDialog.Builder login_failed = new AlertDialog.Builder(MainActivity.this);
            login_failed.setMessage("Login Failed, invalid credentials")
                 .setPositiveButton("OK", new DialogInterface.OnClickListener() {
                     @Override
                     public void onClick(DialogInterface dialog, int which) {

                     }
                 });

             AlertDialog alert = login_failed.create();
             alert.show();
        }
    }
}

Do the same for your UserLogin class.

In case of having multiple API calls in a single Activity or Fragment, you might want to keep a flag in the VolleyAPIService class and passing that to the callback function you can detect which API response you are getting in your onSuccess callback.

Hope that is clear. Please feel free to ask any questions.

what are the advantages of using callback in android and not a instantiated object

Purpose of callbacks is for asynchronous communication. You tell somebody that let me know when something happened through callback (phone number). Apart from this, the advantage I felt with callbacks is that:

- you can avoid dependency between the classes.

- helps avoiding memory leaks.

Take an example of communication from fragment to activity. Though you can call getActivity().aMethodInActivity() it is not preferable because it violates one of the purpose of fragments that is ''reusability'. And we may tend to pass activity instance to fragment which may lead to activity leaks.

Same is the case with fragments and adapters. Communication from adapter to fragment should happen using callbacks. Otherwise if fragment is passed as parameter to adapter, adapter is holding reference to fragment and fragment is holding the reference of adapter. This may lead to leaks.

I tried to explain the advantage of callbacks from android perspective with couple of examples I know. You can explore further.

How to get a callback from Android system to the app?

I guess no way to receive the callback information because ACTION_CALL does not return a result. You can see the output is nothing from docs even you use startActivityForResult

Callback in Android?

i want to know what it means, tell
us technically

http://en.wikipedia.org/wiki/Callback_%28computer_science%29

"In object-oriented programming languages without function-valued arguments, such as Java, [callbacks] can be simulated by passing an abstract class or interface, of which the receiver will call one or more methods, while the calling end provides a concrete implementation. Such objects are effectively a bundle of callbacks, plus the data they need to manipulate. They are useful in implementing various design patterns such as Visitor, Observer, and Strategy."

how i can manage the callback of the
applications

I have no idea what this means.

---

Related Topics