在Android中加载变量的自定义启动屏幕

我开始研究这个： 我的应用程序可以完美地使用这种方法。 不幸的是，我已经开发了一个定制的启动屏幕（不是像另一篇文章中那样的进度对话框），我不能使用相同的方法。我的splashscreen是一个不同的活动，我从onCreate开始将它称为一个不同的线程

而不是

this.pd=ProgressDialog.show（这是“正在工作…”、“正在下载数据…”，true，false）在onCreate中，我执行以下操作：

        Thread splashThread = new Thread() {
                @Override
                public void run() {
                     // start the splash screen activity
                }
        };
        splashThread.start();
 }

splashscreeen活动将正确启动。
因此，我在默认方法（doInBackground、onPostExecute）中调用AsyncTask，在doInBackground中加载所有变量后，我无法结束运行splashscreen的活动并返回到主任务

有什么建议吗？
我不知道我是否会这样做，因为Android有一些很好的处理程序方法，可以做一些你正在寻找的事情，然后你可以阻止线程，直到你的项目下载。下面是我如何制作标准启动屏幕的。此启动活动是清单中的主要活动，完成后将调用下一个活动

import java.io.File;
import android.app.Activity;
import android.bluetooth.BluetoothAdapter;
import android.content.Intent;
import android.os.Bundle;
import android.os.Environment;
import android.os.Handler;
import android.util.Log;
import android.widget.Toast;

/**
 * Splash screen to start the app and maybe check if some things enabled
 * If not enabled popup and if user enables then continue else close app.
 */
public class Splash extends Activity {
    private static final String TAG = "Splash";

    @Override
    public void onCreate(Bundle bundle) {
        super.onCreate(bundle);
        setContentView(R.layout.splash);

        // load some stuff 
        (new Handler()).postDelayed(new splashHandler(), 2000);
    }

    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        Log.d(TAG, "OnActivity result code = " + resultCode);
        super.onActivityResult(requestCode, resultCode, data);

        if (resultCode == -1) {
           // class of the next activity you want to display after the Splash screen
           Class<?> className = MainApp.class;
       startActivity(new Intent(getApplication(), className ));
       Splash.this.finish();

    } else {
          Toast.makeText(Splash.this, getResources().getText(R.string.stringSplashonActivity), Toast.LENGTH_LONG).show();
          finish();
          // the program...
          return;
        }
    }

    /**
     * Runnable class to check if user is logged in already
     * and then start the correct activity.
     *
     */
    class splashHandler implements Runnable{

        @Override
        public void run() {

            .....Do something.....
        }
    }
}

导入java.io.File；
导入android.app.Activity；
导入android.bluetooth.BluetoothAdapter；
导入android.content.Intent；
导入android.os.Bundle；
导入android.os.Environment；
导入android.os.Handler；
导入android.util.Log；
导入android.widget.Toast；
/**
*启动应用程序的启动屏幕，可能会检查是否启用了某些功能
*若未启用弹出窗口，若用户启用，则继续，否则关闭应用程序。
*/
公共课堂活动{
私有静态最终字符串TAG=“Splash”；
@凌驾
创建公共void（Bundle）{
super.onCreate（bundle）；
setContentView（R.layout.splash）；
//装些东西
（新处理程序（））.postDelayed（新处理程序（），2000）；
}
@凌驾
受保护的void onActivityResult（int请求代码、int结果代码、意图数据）{
Log.d（标记“OnActivity result code=“+resultCode”）；
super.onActivityResult（请求代码、结果代码、数据）；
如果（结果代码==-1）{
//要在启动屏幕后显示的下一个活动的类
Class className=MainApp.Class；
startActivity（新意图（getApplication（），className））；
Splash.this.finish（）；
}否则{
Toast.makeText（Splash.this，getResources（）.getText（R.string.stringSplashonActivity），Toast.LENGTH_LONG.show（）；
完成（）；
//节目。。。
返回；
}
}
/**
*Runnable类检查用户是否已登录
*然后开始正确的活动。
*
*/
类splashHandler实现可运行{
@凌驾
公开募捐{
……做点什么。。。。。
}
}
}

然后别忘了在Android Manifest.xml中定义applicaton标记之间的活动（对于Android新手）



希望这能有所帮助……
好吧，我最后感谢JPM提出使用处理程序的建议，我解决了这个问题：

public class SplashScreen extends Activity {

        private static Handler mHandler ;
        private static Handler mainHandler ;

        protected static final int CLOSE_SPLASH = 0 ;

        /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.splash_screen);

        mHandler = new Handler(){
                @Override
                public void handleMessage(Message msg){
                        switch(msg.what){
                        case CLOSE_SPLASH:
                        finish();
                        break;
                        }

                }
        };
    }

    @Override
    public void onStart(){
        super.onStart();
        if(mainHandler != null){
                mainHandler.sendEmptyMessage(MainActivity.START_LOAD);
        }
    }

    @Override
    public boolean onKeyDown (int keyCode, KeyEvent event){
        if(keyCode == KeyEvent.KEYCODE_BACK){
                mainHandler.sendEmptyMessage(MainActivity.ABORT_LOAD);
        }
        return super.onKeyDown(keyCode, event) ;
    }
    public static void setMainHandler(Handler h){
        mainHandler = h ;
    }
    public static void sendMessage(Message msg){
        mHandler.sendMessage(msg);
    }
    public static void sendMessage(int w){
        mHandler.sendEmptyMessage(w);
    }
}

在MainActivity中，我来回管理处理程序：

public class MainActivity extends Activity {

        private MainActivity _this;
        private Handler mHandler;

        protected static final int FINISH_LOAD = 0 ;
        protected static final int START_LOAD = 1 ;
        protected static final int ABORT_LOAD = 2 ;

        /** Called when the activity is first created. */
        @Override
        public void onCreate(Bundle savedInstanceState) {
                super.onCreate(savedInstanceState);

                _this = this;

                mHandler = new Handler() {
                        @Override
                        public void handleMessage(Message msg) {
                                switch (msg.what) {
                                case FINISH_LOAD:
                                   SplashScreen.sendMessage(SplashScreen.CLOSE_SPLASH);
                                        break;
                                case START_LOAD:
                                        initializing();
                                        break;
                                case ABORT_LOAD:
                                        finish();
                                }

                        }
                };
                startSplash();
        }

        private void startSplash() {
                Intent intent = new Intent(this, SplashScreen.class);
                SplashScreen.setMainHandler(mHandler);
                startActivity(intent);
        }

        private void initializing() {
                new Thread() {
                        @Override
                        public void run() {    
                                long start_time = android.os.SystemClock.uptimeMillis();
                                doTheHeavyJob();
                                long duration = android.os.SystemClock.uptimeMillis() - start_time;
                                if (duration <=3000) {
                                   try {
                                       wait(3000-duration);
                       } catch (InterruptedException e) {
                          e.printStackTrace();
                    }
                        }
                        mHandler.sendEmptyMessage(FINISH_LOAD);
                  }
            }.start();
        }    
}

公共类MainActivity扩展活动{
私人主要活动；
私人经理人；
受保护的静态最终整修荷载=0；
受保护静态最终整数启动\负载=1；
受保护的静态最终中断负载=2；
/**在首次创建活动时调用*/
@凌驾
创建时的公共void（Bundle savedInstanceState）{
super.onCreate（savedInstanceState）；
_这个=这个；
mHandler=新处理程序（）{
@凌驾
公共无效handleMessage（消息消息消息）{
开关（msg.what）{
外壳光洁度和负载：
SplashScreen.sendMessage（SplashScreen.CLOSE_SPLASH）；
打破
箱子启动荷载：
初始化（）；
打破
案例中止\u加载：
完成（）；
}
}
};
startSplash（）；
}
私有void startSplash（）{
Intent Intent=新Intent（这是SplashScreen.class）；
SplashScreen.setMainHandler（mHandler）；
星触觉（意向）；
}
私有void初始化（）{
新线程（）{
@凌驾
public void run（）{
长启动时间=android.os.SystemClock.uptimeMillis（）；
做这项繁重的工作（）；
long duration=android.os.SystemClock.uptimeMillis（）-开始时间；
如果（处理程序的想法很有趣，也许我应该深入研究一下。你能告诉我更多吗？根据android的手册：处理程序允许你发送和处理与线程的MessageQueue关联的消息和可运行对象。每个处理程序实例都与一个线程和该线程的消息队列关联。当你创建一个ew处理程序，它被绑定到正在创建它的线程的线程/消息队列——从那时起，它将向该消息队列传递消息和可运行文件，并在它们从消息队列中出来时执行它们将消息和可运行程序安排为将来某个时间点执行；以及（2）将要在不同线程上执行的操作排队。很高兴这样做有效，也很高兴我能以某种方式提供帮助。Chee
public class MainActivity extends Activity {

        private MainActivity _this;
        private Handler mHandler;

        protected static final int FINISH_LOAD = 0 ;
        protected static final int START_LOAD = 1 ;
        protected static final int ABORT_LOAD = 2 ;

        /** Called when the activity is first created. */
        @Override
        public void onCreate(Bundle savedInstanceState) {
                super.onCreate(savedInstanceState);

                _this = this;

                mHandler = new Handler() {
                        @Override
                        public void handleMessage(Message msg) {
                                switch (msg.what) {
                                case FINISH_LOAD:
                                   SplashScreen.sendMessage(SplashScreen.CLOSE_SPLASH);
                                        break;
                                case START_LOAD:
                                        initializing();
                                        break;
                                case ABORT_LOAD:
                                        finish();
                                }

                        }
                };
                startSplash();
        }

        private void startSplash() {
                Intent intent = new Intent(this, SplashScreen.class);
                SplashScreen.setMainHandler(mHandler);
                startActivity(intent);
        }

        private void initializing() {
                new Thread() {
                        @Override
                        public void run() {    
                                long start_time = android.os.SystemClock.uptimeMillis();
                                doTheHeavyJob();
                                long duration = android.os.SystemClock.uptimeMillis() - start_time;
                                if (duration <=3000) {
                                   try {
                                       wait(3000-duration);
                       } catch (InterruptedException e) {
                          e.printStackTrace();
                    }
                        }
                        mHandler.sendEmptyMessage(FINISH_LOAD);
                  }
            }.start();
        }    
}