从应用程序类执行 Activity 的 AsyncTask

Question

我正在尝试找到一种方法来自动执行 AsyncTask，目前它可以通过按下按钮来工作。

提供一些上下文 -

应用程序类

// The Handler that gets information back from the BluetoothService
public final Handler mHandler = new Handler() {
    @Override
    public void handleMessage(Message msg) {
        switch (msg.what) {                
            case MESSAGE_READ:
                Log.d(TAG, "MESSAGE_READ");
                byte[] readBuf = (byte[]) msg.obj;
                readMessage = new String(readBuf);
                break;
        }
    }
};

Activity - AsyncTask 子类

private class PostTask extends AsyncTask<Void, Void, Void> {

    @Override
    protected void onPreExecute() {
        super.onPreExecute();
        readBuf = ((MyApplication) getApplication()).getReadBuf();
        speedcur1 = speedometer.getCurrentSpeed();
        speedcur2 = speedometer1.getCurrentSpeed();
    }

    @Override
    protected Void doInBackground(Void... params) {
        if (readBuf.startsWith("V")) {
            readBuf = readBuf.replace("V", "");
            String[] parts = readBuf.split(",");
            String part1 = parts[0];
            String part2 = parts[1];
            speed1 = Float.parseFloat(part1);
            speed2 = Float.parseFloat(part2);
            finalspeed1 = ((speed1 * 102) / 100);
            finalspeed2 = ((speed2 * 602) / 100);
        }
        return null;
    }

    @Override
    protected void onProgressUpdate(Void... values) {
        super.onProgressUpdate(values);
    }

    @Override
    protected void onPostExecute(Void result) {
        super.onPostExecute(result);
        speedometer.onSpeedChanged(speedometer.getCurrentSpeed() - speedcur1);
        speedometer.onSpeedChanged(speedometer.getCurrentSpeed() + finalspeed1);
        speedometer1.onSpeedChanged(speedometer1.getCurrentSpeed() - speedcur2);
        speedometer1.onSpeedChanged(speedometer1.getCurrentSpeed() + finalspeed2);
        myLabel.setText(readBuf);
    }
}

我已经扩展了我的 Application 类，在这个类内部是一个处理程序，它读取从我的服务发送的消息，msg.arg1 在这个处理程序内部被读取并选择适当的情况。

在我的 message_read 案例中，msg.obj 保存为 byte[]，然后保存为 String。

我目前的想法是在检查相关活动当前是否正在运行后，以某种方式从应用程序类处理程序执行我的活动中的 AsynTask。最初我让这个功能在一个循环中工作，但是在对我的应用程序进行巨大更改后，要求发生了变化，因为蓝牙连接服务在两个活动之间共享。

Answer 1

1.创建接口

2.在活动中实现该接口。

3.然后，将该接口从活动注册到应用程序类中

4.After than do 从应用类回调

5.确保在 onDestroy 或 onStop 中取消注册

public class ApplicationClass extends Appliation{

    private static ApplicationClass instance;
    private TestInterface mCallBack;

    public final Handler mHandler = new Handler() {
    @Override
    public void handleMessage(Message msg) {
        switch (msg.what) {                
            case MESSAGE_READ:
                if(mCallBack!=null){
                  mCallBack.doSomething();
                }
                break;
        }
    }
};


    public void onCreate(){
       instance = this;
    }


    public ApplicationClass getInstance(){
        return instance;
    }

    public void register(TestInterface callBack){
      mCallBack = callBack;
    }

    public void unRegister(){
      mCallBack = null;
    }



}

public interface TestInterface{

    void doSomething();

}

public class MainActivity extends Activity implements TestInterface{

  @Override 
  public void doSomething(){

  }

  @Override 
  public void onStop(){
   ApplicationClass.getInstance().unRegister();
  }

  @Override
  public void onStart(){
   ApplicationClass.getInstance().register(this);
  }

}

Answer 2

是的，您可以从应用程序类运行AsyncTask 并根据您的逻辑检查是否运行？

    public class BaseJuiceApplication extends Application  {

        public static BaseJuiceApplication instance = null;

        public static Context getInstance() {
            if (null == instance) {
                instance = new BaseJuiceApplication();
            }
            return instance;
        }

        @Override
        public void onCreate() {
            super.onCreate();

            if(getPrefs.getBoolean("MyKKey")){
              // any of your logic 
                 new LongOperation().execute("");
                }

        }

    private class LongOperation extends AsyncTask<String, Void, String> {

        @Override
        protected String doInBackground(String... params) {

            return "Executed";
        }

        @Override
        protected void onPostExecute(String result) {
        }

        @Override
        protected void onPreExecute() {}

    }
  }
}