好吧，我有两个后台任务（异步任务）的活动类已经在两个独立的类定义像
public class GettingBeaconsList extends AsyncTask<String, String, String>
public class GettingAirports extends AsyncTask<String, String, String>
这被初始化，并且在执行MainClass
public class MainClass extends Activity implements DelegateTaskCompleted
{
int ServiceBoolean = 0;
public OnClickListener LoadingBeaconList = new OnClickListener()
{
public void onClick(View v)
{
ServiceBoolean =1;
new GettingBeaconsList (context,MainClass.this).execute();
}
}
public OnClickListener LoadingAirportList= new OnClickListener()
{
public void onClick(View v)
{
ServiceBoolean =2;
new GettingAirports(context,MainClass.this).execute();
}
}
@Override
public void JsonArrayLoaded(JSONArray result)
{
// bla bla or whatever here i write, does not matter
if(ServiceBoolean == 1) {
// Load activity 5
}
else if( ServiceBoolean == 2)
{
// Load activity 6
}
else if( ServiceBoolean==3 )
{
// display Toast or Alert Box or load Activity number 8
}
}
}
现在，在上面的代码MainClass.this被存储为界面参考在AsynTask子类这样
private Context context = null;
private DelegateTaskCompleted delegate = null;
public GettingBeaconsList (Context context,DelegateTaskCompleted delegate)
{
this.context = context;
this.delegate = delegate;
}
// And constructor of second AsynTask is same as of First AsynTask Class
private Context context = null;
private DelegateTaskCompleted delegate = null;
public GettingAirports (Context context,DelegateTaskCompleted delegate)
{
this.context = context;
this.delegate = delegate;
}
每个AsynTask类别或亚类的onPostExecute，JSONArray返回或传回给调用的类，如下所示。 在这种情况下调用类是MainClass但也有它们使用相同的AsynTask类其他活动类（GettingBeaconsList和GettingAirports）
protected void onPostExecute(String file_url)
{
pDialog.dismiss();
delegate.JsonArrayLoaded(gotNearestbeacons);
}
现在我有一个MainClass法（JsonArrayLoaded），以解决两个响应从两个不同的后台任务或服务的未来。 我使用的条件，找出哪些服务/类或执行AsynTask。
但我要求解决这样的场景，就好像我们在未来的5个或更多的后台服务，他们也只是返回一个JSON阵列所以，我需要做独立的接口为每个服务的最佳方式是什么？
应该怎样面向对象的出路这种情况？
Answer 1:
最简单的解决方案，我能想到的是修改DelegateTaskCompleted接口，以便它看起来像这样：
public interface DelegateTaskCompleted{
public void JsonArrayLoaded(AsyncTask<String, String, String> task,
JSONArray result);
}
然后你onPostExecute将自己送回象下面这样：
protected void onPostExecute(String file_url)
{
pDialog.dismiss();
delegate.JsonArrayLoaded(this, gotNearestbeacons);
}
最后，在你的MainClass ，你可以有根据的类型条件检查AsyncTask ：
@Override
public void JsonArrayLoaded(AsyncTask<String, String, String> task,
JSONArray result)
{
if(task instanceof GettingBeaconsList) {
// do stuff related to the beacon list
}
else if(task instanceof GettingAirports) {
// do airport list stuff
}
}
这样，你可以很容易地识别出AsyncTask通过响应发送，而不需要跟踪它，如果一个需要比其他等长
可替代地，具有延伸另一个类AsyncTask ，但增加了一个抽象的变量进行识别。
public class TrackableAsyncTask extends AsyncTask<String, String, String>{
public abstract int getId();
public static final int ID_AIRPORT = 1;
public static final int ID_BEACONS = 2;
... etc
}
然后让你的机场和信标AsycTasks去继承这一点。 这将要求他们执行getId方法。
public class GettingAirports extends AsyncTask<String, String, String> {
public int getId(){
return ID_AIRPORT;
}
}
然后，而不是做一个条件if (task instanceof GettingAirports)你可以做一个switch语句象下面这样：
switch(task.getId()){
case TrackableAsyncTask.ID_AIRPORT:
// run airport code
}
希望这可以帮助。
Answer 2:
你好这个代码将会帮助你
这是回调接口
public interface CallbackReceiver {
public void receiveData(Object result);
}
使用的AsyncTask类为抽象类
public abstract class JsonDataCallback extends AsyncTask<String, String, String> implements CallbackReceiver {
private ProgressDialog mProgressDialog;
Handler handler;
Runnable callback;
Activity activity;
public JsonDataCallback(Activity activity)
{
this.activity=activity;
mProgressDialog = new ProgressDialog(activity);
mProgressDialog.setMessage("Loading Please Wait.");
mProgressDialog.setIndeterminate(false);
mProgressDialog.setMax(100);
mProgressDialog.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL);
mProgressDialog.setCancelable(true);
}
public abstract void receiveData(Object object);
@Override
protected void onPreExecute() {
mProgressDialog =ProgressDialog.show(activity, "", "Please Wait",true,false);
super.onPreExecute();
}
@Override
protected String doInBackground(String... aurl) {
String results="";
// do stuff
return results;
}
@Override
protected void onPostExecute(String jsonData) {
if (mProgressDialog != null || mProgressDialog.isShowing()){
mProgressDialog.dismiss();
}
if(jsonData!=null)
{
receiveData(jsonData);
}
}
}
而在你的代码中使用它像这样
String url = ipaddress + "/GrantAdvanceList;
JsonDataCallback callbackservice = new JsonDataCallback(yourActivity.this) {
@Override
public void receiveData(Object object) {
jsonRecordsData = (String)object;
//do stuff with call back data
}
};
callbackservice.execute(url, null, null);
你可以重用的代码这种方式，我希望这会帮助你。 提前致谢。
Answer 3:
您也可以考虑处理程序来实现这一目标。 在活动创建的处理程序，通过这个处理对象的每个的AsyncTask。 在onPOST等调用handler.sendEmptyMessage（CONSTANT_INT）; 在处理程序的handleMessage检查msg.what在if或switch这种方式处理的只有一个对象将被创建并从一个活动多次呼吁异步内使用
Answer 4:
如果我没有理解你的问题，你已经延长的AsyncTask若干次。 每个子类的目标是一个JSONArray传递到实现DelegateTaskCompleted，在那里你会做一些给它的活动。 我们面临的挑战是，根据其产生的AsyncTask这是你想要做这个JSONArray的“东西”是不同的。
去关闭这些假设，有很多不同的方法可以区分哪些的AsyncTask的JSONArray来自何处：
- 创建一个静态变量，如int，在DelegateTaskCompleted类文件JSONArray的每种需要处理。 参数添加到
JsonArrayLoaded同类型此变量的。 然后，使用该检查这个变量与设定你的if-else语句或switch语句和执行基于关闭它的操作将JSONArray。 - 如果你有机会到任何正在生成JSONArray，使0 index数组包含的信息，如何解析它。 （也许是你可以用比较的if-else或开关）
- 如你所说创建用于每个的AsyncTask一个单独的接口，或者与多个方法中的一个单一的接口。
只有选择3是一种面向对象的解决方案，并作为已经在评论，没有一个伟大的，由于可扩展性被指出。 这绝不是一个完整的清单，只是我的一些想法。
我想知道，不过，如果它是值得的，以介绍的方式使用接口可言，或者至少。 既然你已经有了不同的子类的AsyncTask来处理产生JSONArrays，为什么不这样做不管它是你正在做他们的内doInBackground()方法关闭主线程，或者至少地方，在这些地方课程的逻辑，和刚刚返回的结果（或可能在数据库中他们的东西并在需要时让他们）。 我想，有可能是一个更好的方式来处理您的AsyncTask继承避免接口都在一起，或至少使用它们不同，如一个单一的接口被所有的AsyncTasks实现。
这将是非常有益的，如果你能澄清你的问题，并解释这两个AsyncTasks和您的业务类型JSONArrayLoaded方法进行，也许你的推理，使用界面，你现在的样子。 很难给这么少的信息OO最佳实践的具体OO答案或意见，以你的代码实际上在做什么，希望达到。
Answer 5:
一个成员变量添加到双方的AsyncTask类，即，
public class GettingBeaconsList extends AsyncTask<String, String, String>
public class GettingAirports extends AsyncTask<String, String, String>
如
private int flag;
写setter方法，作为
public void setFlag(int flag)
{
this.flag = flag;
}
在MainClass：
GettingBeaconsList beaconsList = new GettingBeaconsList(context,MainClass.this);
beaconsList.setFlag(100); //Declare this flag in integer constant.
beaconsList.execute();
GettingAirports airports = new GettingAirports(context, MainClass.this);
airports.setFlag(200);
airports.execute();
在这两个的AsyncTask类通过标志和委托的方法： -
protected void onPostExecute(String file_url)
{
pDialog.dismiss();
delegate.JsonArrayLoaded(gotNearestbeacons, flag);
//Change the signature of this method
}
同样是在MainClass处理响应： -
@Override
public void JsonArrayLoaded(JSONArray result, int flag)
{
// Here check which Background task has been completed
if(flag == 100) // GettingBeaconsList is executed
if(flag == 200) // GettingAirport is executed.
// bla bla or whatever here i write, does not matter
if(ServiceBoolean == 1) {
// Load activity 5
}
else if( ServiceBoolean == 2)
{
// Load activity 6
}
else if( ServiceBoolean==3 )
{
// display Toast or Alert Box or load Activity number 8
}
}
Answer 6:
我建议你简单地使用你的活动，其实施ň内部类DelegateTaskCompleted 。 这很简单，高效，清晰和易于理解的（认为维护） - 和你已经通过委托当你构建你的AsyncTasks，所以不可能是你已经对你的心这种做法？
public class MainClass extends Activity {
// probabnly not static ;)
private final class BeaconsDelegate implements DelegateTaskCompleted ...
private final class AirportsDelegate implements DelegateTaskCompleted ...
}
文章来源: How one interface can be used for different background android tasks?
