Android 如何在 android 的启动画面中等待调用

Question

我的场景是我有 5 个线程并行调用发生在启动画面 activity 但我需要等待一个特定的线程（它是 DashBoardCallable）执行以便我可以加载仪表板数据，显示启动画面直到仪表板数据被加载，一旦仪表板数据被加载更改 activity 同时我在后台加载更多与该用户相关的数据（这是线程 util class 会做的）。

或者你可以这样理解我有一个用于并行调用的 5 个线程的 ExecutorService，而 Splashscreen 基于 5 个中的一个线程执行。一旦这个线程执行完成，改变 activity 留下其余线程在后台执行。

下面是启动画面activity代码：

    ExecutorService executor = Executors.newFixedThreadPool(5);

            SharedPreferences        sharedpreferences = getSharedPreferences(getResources().getString(R.string.mypreference_key), Context.MODE_PRIVATE);
            final SharedPreferences.Editor editor = sharedpreferences.edit();
            ThreadUtil datatype1 = new ThreadUtil(editor,3504,"URL","DATATYPE1","DATATYPE1");
            ThreadUtil datatype2 = new ThreadUtil(editor,3504,"URL","DATATYPE2","DATATYPE2");
            ThreadUtil datatype3 = new ThreadUtil(editor,3504,"URL","DATATYPE3","DATATYPE3");
            ThreadUtil datatype4 = new ThreadUtil(editor,3504,"Different URL","DATATYPE1","DATATYPE1");
                    DashBoardCallable dashBoardCallable = new DashBoardCallable(SplashScreenActivity.this,3504);
    FutureTask<String> dashboardFuture = new FutureTask<String>(dashBoardCallable);
            executor.execute(datatype1);
            executor.execute(datatype2);
            executor.execute(datatype3);
            executor.execute(datatype4);
executor.execute(dashboardFuture);
            String response =dashboardFuture.get();

这是可调用的仪表板：

public class DashBoardCallable implements Callable<String> {
    private Context context;
    private int user_id;
    public DashBoardCallable(Context context,int user_id){
        this.context = context;
        this.user_id = user_id;
    }

    @Override
    public String call() throws Exception {
        HttpUtil httpUtil = new HttpUtil();

        httpUtil.setUrl("URL");
        httpUtil.setType("GET");

        return httpUtil.getStringResponse();
    }
}

这是 threadUtil class:

public class ThreadUtil implements Runnable {
    private int user_id;
    private String url,type,stored_name;
    private SharedPreferences.Editor editor;
    public ThreadUtil( SharedPreferences.Editor editor, int user_id, String url, String type,String stored_name){
        this.editor = editor;
        this.user_id = user_id;
        this.url = url;
        this.type = type;
        this.stored_name = stored_name;
    }

    @Override
    public void run() {
        HttpUtil httpUtil = new HttpUtil();
        httpUtil.setUrl(url);
        httpUtil.setType("GET");
        String jsonresponse =httpUtil.getStringResponse();
        Gson gson = new Gson();
        switch (type){
            case "DATATYPE1":
                saveDATATYPE1(jsonresponse,gson,editor);
                break;
            case "DATATYPE2":
                saveDATATYPE2(jsonresponse,gson,editor);
                break;
            case "DATATYPE3":
                saveDATATYPE3(jsonresponse,gson,editor);
                break;
        }


    }

    private void saveDATATYPE1(String jsonresponse, Gson gson,SharedPreferences.Editor editor) {
        if(!jsonresponse.equalsIgnoreCase("null")){
            editor.putString(stored_name, jsonresponse);
            editor.apply();
            editor.commit();
        }
    }

    private void saveDATATYPE2(String jsonresponse, Gson gson, SharedPreferences.Editor editor) {
        try {
            Type listType = new TypeToken<List<AssessmentPOJO>>() {}.getType();
            ArrayList<AssessmentPOJO> dashboardCards = (ArrayList<AssessmentPOJO>) gson.fromJson(jsonresponse, listType);
            for(AssessmentPOJO assessmentPOJO:dashboardCards){
                System.out.println("XXBBXBXBXBXB -> "+assessmentPOJO.getName());
                if(assessmentPOJO != null){
                    editor.putString(stored_name+assessmentPOJO.getId(), gson.toJson(assessmentPOJO));
                    editor.apply();
                    editor.commit();
                }
            }
        }catch (JsonSyntaxException jse){
            jse.printStackTrace();
        }catch (Exception e){

        }
    }
    private void saveDATATYPE3(String jsonresponse, Gson gson,SharedPreferences.Editor editor) {
        if(!jsonresponse.equalsIgnoreCase("null")) {
            Type listType = new TypeToken<List<CoursePOJO>>() {}.getType();
            ArrayList<CoursePOJO> coursePOJOs = (ArrayList<CoursePOJO>)gson.fromJson(jsonresponse, listType);
            for(CoursePOJO coursePOJO:coursePOJOs){
                if(coursePOJO != null){
                    editor.putString(stored_name+coursePOJO.getId(), gson.toJson(coursePOJO));
                    editor.apply();
                    editor.commit();
                }
            }
        }
        }
}

这是 HttpUtil class:

public class HttpUtil {
    private String url;
    private String type;
    private HashMap<String,String> param;
    private String postrequest;
    public HttpUtil(){}
    private int socketTimeOut=0, connectionTimeOut=0;

    public HttpUtil(String url, String type, HashMap<String, String> param,String postrequest) {
        this.url = url;
        this.type = type;
        this.param = param;
        this.postrequest = postrequest;
    }


    public String getStringResponse(){
        String jsonresponse="";
        try {
            System.out.println("url "+url);
            System.out.println("type "+type);

            HttpResponse httpResponse = getHttpResponse();
            if (httpResponse != null && httpResponse.getStatusLine().getStatusCode() == HttpURLConnection.HTTP_OK) {
                HttpEntity httpEntity = httpResponse.getEntity();
                jsonresponse = EntityUtils.toString(httpEntity);
                if(jsonresponse.equalsIgnoreCase("[]")){
                    jsonresponse="";
                }
                System.out.println("HttpUtil Response is .... " + jsonresponse);
            } else {
                return "null";
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

        return jsonresponse;
    }
    public void getVoidResponse(){

    }

    public String getUrl() {
        return url;
    }

    public void setUrl(String url) {
        this.url = url;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public HashMap<String, String> getParam() {
        return param;
    }

    public void setParam(HashMap<String, String> param) {
        this.param = param;
    }

    private HttpResponse getHttpResponse(){
        HttpResponse httpResponse = null;
        HttpClient httpclient = new DefaultHttpClient();
        try{
        switch(type){
            case "GET":
                if(socketTimeOut != 0 && connectionTimeOut != 0){
                    HttpParams httpParameters = new BasicHttpParams();
                    HttpConnectionParams.setConnectionTimeout(httpParameters, connectionTimeOut);
                    HttpConnectionParams.setSoTimeout(httpParameters, socketTimeOut);
                    httpclient = new DefaultHttpClient(httpParameters);
                }
                httpResponse = httpclient.execute(new HttpGet(url));

                break;
            case "POST":
                List<NameValuePair> nameValuePairs = new ArrayList<NameValuePair>();
                if(param != null) {
                    for (String key : param.keySet()) {
                        nameValuePairs.add(new BasicNameValuePair(key, param.get(key)));
                    }
                }
                HttpPost httpPost = new HttpPost(url);
                httpPost.setEntity(new UrlEncodedFormEntity(nameValuePairs));
                httpResponse = httpclient.execute(httpPost);
                break;
            case "PUT":
                HttpPut httpPut = new HttpPut(url);
                if(postrequest != null){
                    StringEntity se = new StringEntity(postrequest);
                    se.setContentType("application/json;charset=UTF-8");//text/plain;charset=UTF-8
                    se.setContentEncoding(new BasicHeader(HTTP.CONTENT_TYPE,"application/json;charset=UTF-8"));
                    httpPut.setEntity(se);
                    httpPut.setHeader("Accept", "application/json");
                    httpPut.setHeader("Content-type", "application/json");
                }
                httpResponse = httpclient.execute(httpPut);
                break;
            default:
                httpResponse = httpclient.execute(new HttpGet(url));
                break;
        } }catch (MalformedURLException e) {
            e.printStackTrace();
            return null;
        } catch (IOException e) {
            e.printStackTrace();
            return null;
        }catch (JsonSyntaxException jse) {
            jse.printStackTrace();
            return null;
        }catch (Exception e){
            e.printStackTrace();
            return null;
        }

        return httpResponse;
    }

    public String getPostrequest() {
        return postrequest;
    }

    public void setPostrequest(String postrequest) {
        this.postrequest = postrequest;
    }

    public int getSocketTimeOut() {
        return socketTimeOut;
    }

    public void setSocketTimeOut(int socketTimeOut) {
        this.socketTimeOut = socketTimeOut;
    }

    public int getConnectionTimeOut() {
        return connectionTimeOut;
    }

    public void setConnectionTimeOut(int connectionTimeOut) {
        this.connectionTimeOut = connectionTimeOut;
    }
}

Answer 1

根据您对线程的使用，我可以告诉您最好使用 AsyncTask。

每个 AsyncTask 都必须有一个回调，Activity 实现它们，以便在任务完成后，Activity 可以控制操作并做出决定。

对于任务：

public class SplashScreenTask extends AsyncTask<Void, Void, Void> {

private Context context;

private SplashScreenTaskCallback listener = null;

public SplashScreenTask (Context context) {
    this.context = context;
}

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

    // Do your tasks


    return null;
}

@Override
public void onPreExecute () {
}

@Override
public void onPostExecute (Void v) {
    if (listener != null) {
        listener.OnSplashScreenTaskCompleted ();
    }
}

public void setListener (SplashScreenTaskCallback listener) {
    this.listener = listener;
}


public interface SplashScreenTaskCallback {
    void OnSplashScreenTaskCompleted ();
}
}

还有你的activity：

public class SplashScreenActivity extends Activity implements SplashScreenTask.SplashScreenTaskCallback {

protected Runnable postDelayedAction;
private final Handler handler = new Handler();

@Override
public void onCreate (Bundle savedInstanceState) {

    Log.d(TAG, "onCreate");

    super.onCreate(savedInstanceState);

    handler.postDelayed(startBackgroundTasks, splashScreenDelay);

}

private Runnable startBackgroundTasks = new Runnable() {

    @Override
    public void run () {

        //  Do initial background tasks like sounds load
        SplashScreenTask task = new SplashScreenTask (SplashScreenActivity.this);
        task.setListener (SplashScreenActivity.this);
        task.execute ();

    }
};

@Override
public void OnSplashScreenTaskCompleted () {
    // Here you take decisions
}
}

Answer 2

我会使用 Rx zip 运算符来确定您的所有后台任务何时完成。使用 Android 框架确定多个并行作业的完成是一件非常令人头疼的事情。

有一种最佳做法，可以在没有初始延迟的情况下显示启动画面，其中您可以使用主题设置可绘制的背景。为了做到这一点并过渡到您的 Activity（不是您的闪屏），您可以在其中实际触发所有这些逻辑，只需在您的 Activity 中复制您的闪屏的视觉效果，然后转出在您的工作完成后展示这些视觉效果。

Android 如何在 android 的启动画面中等待调用

Android how to wait for a callable in Splash Screen in android

android

splash-screen

executorservice