Question

我想让我的应用看起来更专业，所以我决定要制作一个闪屏。

我如何创建它然后实现它？

Answer 1

请注意，此解决方案不会让用户等待更多：启动画面的延迟取决于应用程序的启动时间。

当你打开任何Android应用程序时，默认情况下你会得到一个带有应用程序标题和图标的黑色屏幕，你可以通过使用样式/主题来改变它。

首先，在values文件夹中创建一个style.xml并为其添加样式。

<style name="splashScreenTheme" parent="@android:style/Theme.DeviceDefault.Light.NoActionBar">
    <item name="android:windowBackground">@drawable/splash_screen</item>
</style>

您可以使用任何其他主题作为父级，而不是使用@android:style/Theme.DeviceDefault.Light.NoActionBar。

其次，在您的应用中，Manifest.xml将android:theme="@style/splashScreenTheme"添加到您的主要活动中。

<activity
        android:name="MainActivity"
        android:label="@string/app_name"
        android:theme="@style/splashScreenTheme" >

第三，在onCreate（）启动活动中更新主题。

protected void onCreate(Bundle savedInstanceState) {
    // Make sure this is before calling super.onCreate
    setTheme(R.style.mainAppTheme);
    super.onCreate(savedInstanceState);
}

<强>更新看看这篇文章https://plus.google.com/+AndroidDevelopers/posts/Z1Wwainpjhd 感谢@ mat1h和@adelriosantiago

Answer 2

进一步阅读：

旧答案：

如何：Simple splash screen

此答案将向您展示如何在应用启动时为固定时间显示启动画面，例如品牌推广的原因。例如。您可以选择显示启动画面3秒钟。但是，如果您想要显示spash屏幕一段时间（例如应用程序启动时间），您应该查看Abdullah的答案https://stackoverflow.com/a/15832037/401025。但请注意，应用程序启动可能在新设备上非常快，因此用户只会看到一个不好用户体验的闪存。

首先，您需要在layout.xml文件中定义spash屏幕

  <?xml version="1.0" encoding="utf-8"?>
  <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
          android:orientation="vertical" android:layout_width="fill_parent"
          android:layout_height="fill_parent">

          <ImageView android:id="@+id/splashscreen" android:layout_width="wrap_content"
                  android:layout_height="fill_parent"
                  android:src="@drawable/splash"
                  android:layout_gravity="center"/>

          <TextView android:layout_width="fill_parent"
                    android:layout_height="wrap_content"
                    android:text="Hello World, splash"/>

  </LinearLayout>

您的活动：

import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.os.Handler;

public class Splash extends Activity {

    /** Duration of wait **/
    private final int SPLASH_DISPLAY_LENGTH = 1000;

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

        /* New Handler to start the Menu-Activity 
         * and close this Splash-Screen after some seconds.*/
        new Handler().postDelayed(new Runnable(){
            @Override
            public void run() {
                /* Create an Intent that will start the Menu-Activity. */
                Intent mainIntent = new Intent(Splash.this,Menu.class);
                Splash.this.startActivity(mainIntent);
                Splash.this.finish();
            }
        }, SPLASH_DISPLAY_LENGTH);
    }
}

多数民众赞成;）

Answer 3

创建活动：Splash
创建布局XML文件：splash.xml
将UI组件放在splash.xml布局中，使其看起来如您所愿

您的Splash.java可能如下所示：

public class Splash extends Activity {
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.splash);

        int secondsDelayed = 1;
        new Handler().postDelayed(new Runnable() {
                public void run() {
                        startActivity(new Intent(Splash.this, ActivityB.class));
                        finish();
                }
        }, secondsDelayed * 1000);
    }
}

将ActivityB.class更改为您希望在启动画面后启动的任何活动
检查您的清单文件，它应该看起来像

        <activity
            android:name=".HomeScreen"
            android:label="@string/app_name">     
        </activity>

        <activity
            android:name=".Splash"
            android:label="@string/title_activity_splash_screen">     
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>

Answer 4

上面的答案非常好，但我想补充一些其他内容。我是Android的新手，我在开发过程中遇到了这些问题。希望这可以帮助像我这样的人。

Splash屏幕是我的应用程序的入口点，因此在AndroidManifest.xml中添加以下行。

    <activity
        android:name=".SplashActivity"
        android:theme="@android:style/Theme.DeviceDefault.Light.NoActionBar">
        <intent-filter>
            <action android:name="android.intent.action.MAIN" />
            <category android:name="android.intent.category.LAUNCHER" />
        </intent-filter>
    </activity>

启动画面应该只在应用程序生命周期中显示一次，我使用布尔变量来记录启动画面的状态，并且只在第一次显示它。

public class SplashActivity extends Activity {
    private static boolean splashLoaded = false;

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

        if (!splashLoaded) {
            setContentView(R.layout.activity_splash);
            int secondsDelayed = 1;
            new Handler().postDelayed(new Runnable() {
                public void run() {
                    startActivity(new Intent(SplashActivity.this, MainActivity.class));
                    finish();
                }
            }, secondsDelayed * 500);

            splashLoaded = true;
        }
        else {
            Intent goToMainActivity = new Intent(SplashActivity.this, MainActivity.class);
            goToMainActivity.setFlags(Intent.FLAG_ACTIVITY_REORDER_TO_FRONT);
            startActivity(goToMainActivity);
            finish();
        }
    }
}

快乐的编码！

Answer 5

创建Activity SplashScreen.java

public class SplashScreen extends Activity {
protected boolean _active = true;
protected int _splashTime = 3000; // time to display the splash screen in ms



@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.splashscreen);

    Thread splashTread = new Thread() {
        @Override
        public void run() {
            try {
                int waited = 0;
                while (_active && (waited < _splashTime)) {
                    sleep(100);
                    if (_active) {
                        waited += 100;
                    }
                }
            } catch (Exception e) {

            } finally {

                startActivity(new Intent(SplashScreen.this,
                        MainActivity.class));
                finish();
            }
        };
             };
    splashTread.start();
}
 }

splashscreen.xml将是这样的

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
  android:layout_width="600px" android:layout_height="1024px"
  android:background="#FF0000">
</RelativeLayout>

Answer 6

默认情况下，Splash Screnn不会自动使您的应用程序看起来更专业。专业设计的Splash Screen有可能使您的应用程序看起来更专业，但如果您不知道如何编写，那么您的应用程序的其余部分实际上将是多么专业。

关于拥有启动画面的唯一原因（借口）是因为您正在进行大量的计算或正在等待GPS / WiFi启动，因为您的应用程序依赖于启动之前的启动。没有这些计算或访问GPS / WiFi（等）的结果，您的应用程序已经死在水中，因此您觉得您需要一个启动画面，并且必须阻止任何其他正在运行的程序的屏幕视图（包括背景））。

这样的启动画面应该看起来像你的全屏幕应用程序，给人的印象是它已经初始化，然后在完成冗长的计算后，可以填写最终的细节（图像调整）。机会就是这种情况，或者它是本程序设计的唯一方式非常小。

最好允许用户（以及操作系统的其余部分）在等待而不是将您的程序设计为依赖于需要一段时间的事情时（当等待的持续时间不确定时）执行其他操作）。

手机上已有图标表示GPS / WiFi正在启动。启动屏幕占用的时间或空间可用于加载预计算或实际执行计算。请参阅下面的第一个链接，了解您创建的问题以及必须考虑的问题。

如果您绝对必须等待这些计算或GPS / WiFi，最好让应用程序启动并弹出一个弹出窗口，说明有必要等待计算（文本“初始化”消息是精细）。等待GPS / WiFi是预期的（如果他们已经没有在另一个程序中启用），所以宣布他们的等待时间是不必要的。

请记住，当启动屏幕启动时，您的程序IS实际上已经运行，您所做的只是延迟使用您的程序并占用CPU / GPU以执行大多数认为不必要的操作。

我们最好真的很想等到每次我们开始你的程序时看到你的启动画面，否则我们不会觉得它是非常专业的。制作启动画面FULL屏幕和实际程序屏幕的副本（所以我们认为它实际上已经初始化它没有）可能完成你的目标（使你的程序看起来更专业）但我不会打赌。

为什么不这样做：http://cyrilmottier.com/2012/05/03/splash-screens-are-evil-dont-use-them/

怎么做：https://encrypted.google.com/search?q=Android+splash+screen+source

所以有充分的理由不去做，但如果你确定你的情况不属于那些例子，那么上面给出了做到这一点的方法。确保它确实使您的应用程序看起来更专业，或者您已经击败了您为此做出的唯一理由。

就像YouTube频道一样，每个视频都有一个冗长的图形介绍（和Outro）或感觉需要讲一个笑话或解释过去一周发生的事情（当它不是喜剧或LifeStyles频道时）。只是展示节目！（只需运行程序）。

Answer 7

以上所有答案都非常好。但是存在内存泄漏问题。此问题在Android社区中通常称为“泄漏活动”。那究竟是什么意思呢？

当发生配置更改（例如方向更改）时，Android会销毁活动并重新创建它。通常情况下，垃圾收集器只会清除旧Activity实例的已分配内存，而且我们都很好。

“泄漏活动”是指垃圾收集器无法清除旧活动实例的已分配内存的情况，因为它是来自活动实例的对象的being (strong) referenced。每个Android应用都有为其分配的特定内存量。当垃圾收集器无法释放未使用的内存时，应用程序的性能将逐渐降低，并最终因OutOfMemory错误而崩溃。

如何确定应用程序是否泄漏内存？最快的方法是在Android Studio中打开“内存”选项卡，并在更改方向时注意分配的内存。如果分配的内存不断增加并且永不减少，那么就会出现内存泄漏。

1.用户更改方向时内存泄漏。

首先，您需要在布局资源splashscreen.xml文件

中定义启动画面

启动画面活动的示例代码。

public class Splash extends Activity {
 // 1. Create a static nested class that extends Runnable to start the main Activity
    private static class StartMainActivityRunnable implements Runnable {
        // 2. Make sure we keep the source Activity as a WeakReference (more on that later)
        private WeakReference mActivity;

        private StartMainActivityRunnable(Activity activity) {
         mActivity = new WeakReference(activity);
        }

        @Override
        public void run() {
         // 3. Check that the reference is valid and execute the code
            if (mActivity.get() != null) {
             Activity activity = mActivity.get();
             Intent mainIntent = new Intent(activity, MainActivity.class);
             activity.startActivity(mainIntent);
             activity.finish();
            }
        }
    }

    /** Duration of wait **/
    private final int SPLASH_DISPLAY_LENGTH = 1000;

    // 4. Declare the Handler as a member variable
    private Handler mHandler = new Handler();

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(icicle);
        setContentView(R.layout.splashscreen);

        // 5. Pass a new instance of StartMainActivityRunnable with reference to 'this'.
        mHandler.postDelayed(new StartMainActivityRunnable(this), SPLASH_DISPLAY_LENGTH);
    }

    // 6. Override onDestroy()
    @Override
    public void onDestroy() {
     // 7. Remove any delayed Runnable(s) and prevent them from executing.
     mHandler.removeCallbacksAndMessages(null);

     // 8. Eagerly clear mHandler allocated memory
     mHandler = null;
    }
}

有关详情，请参阅此link

Answer 8

阿卜杜拉的回答很棒。但我希望在回答中添加一些细节。

实施启动画面

以正确的方式实现启动画面与您想象的有点不同。您看到的启动视图必须立即就绪，即使您可以在启动活动中为布局文件充气之前也是如此。

所以你不会使用布局文件。而是将启动画面的背景指定为活动的主题背景。为此，首先在res / drawable中创建一个XML drawable。

background_splash.xml

<?xml version="1.0" encoding="utf-8"?>
<layer-list xmlns:android="http://schemas.android.com/apk/res/android">

    <item
        android:drawable="@color/gray"/>

    <item>
        <bitmap
            android:gravity="center"
            android:src="@mipmap/ic_launcher"/>
    </item>

</layer-list>

它只是一个带有徽标的中心背景颜色的图层列表。

现在打开styles.xml并添加此样式

<style name="SplashTheme" parent="Theme.AppCompat.NoActionBar">
        <item name="android:windowBackground">@drawable/background_splash</item>
</style>

这个主题必须是动作栏和我们刚才创建的背景。

在清单中，您需要将SplashTheme设置为您想要用作启动的活动。

<activity
android:name=".SplashActivity"
android:theme="@style/SplashTheme">
<intent-filter>
    <action android:name="android.intent.action.MAIN" />

    <category android:name="android.intent.category.LAUNCHER" />
</intent-filter>

然后在您的活动代码中，在使用意图启动后将用户导航到特定屏幕。

public class SplashActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        Intent intent = new Intent(this, MainActivity.class);
        startActivity(intent);
        finish();
    }
}

这是正确的方法。我用这些参考文献作答案。

https://material.google.com/patterns/launch-screens.html
https://www.bignerdranch.com/blog/splash-screens-the-right-way/ 感谢这些家伙让我走向正确的方向。我想帮助别人，因为建议不要接受答案来做闪屏。

Answer 9

在Android Marshmallow 之后，我想到的其他有效使用Splash屏幕的是在您应用的启动画面中请求必要的Android Permissions 。

似乎大多数应用都以这种方式处理权限请求。

对话框造成糟糕的UIX并且他们打破主流并让你决定运行时和真相是大多数用户可能甚至不关心你的应用是否想要在SD卡上写东西。在我们用简单的英语翻译之前，他们中的一些人可能甚至不理解我们要传达的内容。
在每次操作之前，一次请求权限会减少“if else”的数量，并使您的代码看起来更加整洁。

这是一个示例，说明如何在运行Android OS 23+的设备的启动活动中请求权限。

如果所有权限都被授予或已经授予或者应用程序正在Pre Marshmallow上运行那么只需稍微延迟半秒即可显示主要内容，这样用户就可以欣赏我们在阅读此问题并努力发挥最大努力时付出的努力

import android.Manifest;
import android.annotation.TargetApi;
import android.app.AlertDialog;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.os.Build;
import android.os.Bundle;
import android.os.Handler;
import android.support.v7.app.AppCompatActivity;
import android.widget.Toast;

import com.c2h5oh.beer.R;
import com.c2h5oh.beer.utils.Animatrix;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class SplashActivity extends AppCompatActivity {

    final private int REQUEST_CODE_ASK_MULTIPLE_PERMISSIONS = 124;

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

        //show animations 
        Animatrix.scale(findViewById(R.id.title_play), 100);
        Animatrix.scale(findViewById(R.id.title_edit), 100);
        Animatrix.scale(findViewById(R.id.title_record), 100);
        Animatrix.scale(findViewById(R.id.title_share), 100);

        if (Build.VERSION.SDK_INT >= 23) {

            // Marshmallow+ Permission APIs
            fuckMarshMallow();

        } else {

            // Pre-Marshmallow
            ///Display main contents
            displaySplashScreen();
        }
    }

    @Override
    public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
        switch (requestCode) {
            case REQUEST_CODE_ASK_MULTIPLE_PERMISSIONS: {
                Map<String, Integer> perms = new HashMap<String, Integer>();
                // Initial
                perms.put(Manifest.permission.READ_EXTERNAL_STORAGE, PackageManager.PERMISSION_GRANTED);
                perms.put(Manifest.permission.RECORD_AUDIO, PackageManager.PERMISSION_GRANTED);
                perms.put(Manifest.permission.MODIFY_AUDIO_SETTINGS, PackageManager.PERMISSION_GRANTED);
                perms.put(Manifest.permission.VIBRATE, PackageManager.PERMISSION_GRANTED);
                // Fill with results
                for (int i = 0; i < permissions.length; i++)
                    perms.put(permissions[i], grantResults[i]);

                // Check for ACCESS_FINE_LOCATION
                if (perms.get(Manifest.permission.READ_EXTERNAL_STORAGE) == PackageManager.PERMISSION_GRANTED
                        && perms.get(Manifest.permission.RECORD_AUDIO) == PackageManager.PERMISSION_GRANTED
                        && perms.get(Manifest.permission.MODIFY_AUDIO_SETTINGS) == PackageManager.PERMISSION_GRANTED
                        && perms.get(Manifest.permission.VIBRATE) == PackageManager.PERMISSION_GRANTED) {
                    // All Permissions Granted

                    // Permission Denied
                    Toast.makeText(SplashActivity.this, "All Permission GRANTED !! Thank You :)", Toast.LENGTH_SHORT)
                            .show();

                    displaySplashScreen();

                } else {
                    // Permission Denied
                    Toast.makeText(SplashActivity.this, "One or More Permissions are DENIED Exiting App :(", Toast.LENGTH_SHORT)
                            .show();

                    finish();
                }
            }
            break;
            default:
                super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        }
    }


    @TargetApi(Build.VERSION_CODES.M)
    private void fuckMarshMallow() {
        List<String> permissionsNeeded = new ArrayList<String>();

        final List<String> permissionsList = new ArrayList<String>();
        if (!addPermission(permissionsList, Manifest.permission.READ_EXTERNAL_STORAGE))
            permissionsNeeded.add("Read SD Card");
        if (!addPermission(permissionsList, Manifest.permission.RECORD_AUDIO))
            permissionsNeeded.add("Record Audio");
        if (!addPermission(permissionsList, Manifest.permission.MODIFY_AUDIO_SETTINGS))
            permissionsNeeded.add("Equilizer");
        if (!addPermission(permissionsList, Manifest.permission.VIBRATE))
            permissionsNeeded.add("Vibrate");

        if (permissionsList.size() > 0) {
            if (permissionsNeeded.size() > 0) {

                // Need Rationale
                String message = "App need access to " + permissionsNeeded.get(0);

                for (int i = 1; i < permissionsNeeded.size(); i++)
                    message = message + ", " + permissionsNeeded.get(i);

                showMessageOKCancel(message,
                        new DialogInterface.OnClickListener() {

                            @Override
                            public void onClick(DialogInterface dialog, int which) {
                                requestPermissions(permissionsList.toArray(new String[permissionsList.size()]),
                                        REQUEST_CODE_ASK_MULTIPLE_PERMISSIONS);
                            }
                        });
                return;
            }
            requestPermissions(permissionsList.toArray(new String[permissionsList.size()]),
                    REQUEST_CODE_ASK_MULTIPLE_PERMISSIONS);
            return;
        }

        Toast.makeText(SplashActivity.this, "No new Permission Required- Launching App .You are Awesome!!", Toast.LENGTH_SHORT)
                .show();

        displaySplashScreen();
    }


    private void showMessageOKCancel(String message, DialogInterface.OnClickListener okListener) {
        new AlertDialog.Builder(SplashActivity.this)
                .setMessage(message)
                .setPositiveButton("OK", okListener)
                .setNegativeButton("Cancel", null)
                .create()
                .show();
    }

    @TargetApi(Build.VERSION_CODES.M)
    private boolean addPermission(List<String> permissionsList, String permission) {

        if (checkSelfPermission(permission) != PackageManager.PERMISSION_GRANTED) {
            permissionsList.add(permission);
            // Check for Rationale Option
            if (!shouldShowRequestPermissionRationale(permission))
                return false;
        }
        return true;
    }

    /**
     * Display main content with little delay just so that user can see
     * efforts I put to make this page
     */
    private void displaySplashScreen() {
        new Handler().postDelayed(new Runnable() {

        /*
         * Showing splash screen with a timer. This will be useful when you
         * want to show case your app logo / company
         */

            @Override
            public void run() {
                startActivity(new Intent(SplashActivity.this, AudioPlayerActivity.class));
                finish();
            }
        }, 500);
    }


}

Answer 10

不应从布局文件加载启动画面，加载时可能会有一些延迟。

最好的方法是为您的SplashScreenActivity创建一个主题，并将the android:windowBackground设置为可绘制的资源。

https://www.bignerdranch.com/blog/splash-screens-the-right-way/

简而言之：

在清单中声明您的SplashScreenActivity：

<activity
        android:name=".activities.SplashScreenActivity"
        android:theme="@style/SplashTheme"
        android:screenOrientation="portrait">
        <intent-filter>
            <action android:name="android.intent.action.MAIN" />
            <category android:name="android.intent.category.LAUNCHER" />
        </intent-filter>
    </activity>

在你的SplashScreenActivity.java中：

@Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    Intent intent = new Intent(this, MainActivity_.class);
    startActivity(intent);
    finish();

}

接下来为主题的背景窗口创建ressource：

<style name="SplashTheme" parent="Theme.Bumpfie.Base">
    <item name="android:windowBackground">@drawable/splash</item>
</style>

可绘制文件splash.xml：

<?xml version="1.0" encoding="utf-8"?>
<layer-list xmlns:android="http://schemas.android.com/apk/res/android">
    <item android:drawable="@android:color/white"/>
    <item>
        <bitmap
            android:gravity="center"
            android:src="@drawable/app_logo"/>
    </item>
</layer-list>

Answer 11

不必要地在4个5的停止屏幕上停止没有多大意义。如果您在后台加载某些内容就行了，否则请按照此方法实现启动画面： - 以正确的方式实现启动画面与您想象的有点不同。您看到的启动视图必须立即就绪，即使您可以在启动活动中为布局文件充气之前也是如此。

所以你不会使用布局文件。而是将启动画面的背景指定为活动的主题背景。为此，首先在res / drawable中创建一个XML drawable。

<?xml version="1.0" encoding="utf-8"?>
<layer-list xmlns:android="http://schemas.android.com/apk/res/android">

    <item
        android:drawable="@color/gray"/>

    <item>
        <bitmap
            android:gravity="center"
            android:src="@mipmap/ic_launcher"/>
    </item>

</layer-list>

在这里，我设置了背景颜色和图像。

接下来，您将把它设置为主题中的启动活动的背景。导航到styles.xml文件并为启动活动添加新主题：

<resources>

    <!-- Base application theme. -->
    <style name="AppTheme" parent="Theme.AppCompat.Light.DarkActionBar">
        <!-- Customize your theme here. -->
    </style>

    <style name="SplashTheme" parent="Theme.AppCompat.NoActionBar">
        <item name="android:windowBackground">@drawable/background_splash</item>
    </style>

</resources>

在新的SplashTheme中，将窗口背景属性设置为XML drawable。在AndroidManifest.xml中将其配置为splash活动的主题：

<activity
    android:name=".SplashActivity"
    android:theme="@style/SplashTheme">
    <intent-filter>
        <action android:name="android.intent.action.MAIN" />

        <category android:name="android.intent.category.LAUNCHER" />
    </intent-filter>
</activity>

最后，SplashActivity类应该将您转发到您的主要活动：

     public class SplashActivity extends AppCompatActivity {

             @Override
             protected void onCreate(Bundle savedInstanceState) {
                super.onCreate(savedInstanceState);

               Intent intent = new Intent(this, MainActivity.class);
               startActivity(intent);
               finish();
    }
}

更多细节阅读： 1。https://www.bignerdranch.com/blog/splash-screens-the-right-way/ 2。http://blog.goodbarber.com/3-tips-to-create-a-great-splash-screen-for-your-mobile-app_a287.html

Answer 12

This is the full code here

SplashActivity.java

char string_buffer[128];

In drawables create this bg_splash.xml

public class SplashActivity extends AppCompatActivity {

private final int SPLASH_DISPLAY_DURATION = 1000;

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


    new Handler().postDelayed(new Runnable(){
        @Override
        public void run() {

            Intent mainIntent = new Intent(SplashActivity.this,MainActivity.class);
            SplashActivity.this.startActivity(mainIntent);
            SplashActivity.this.finish();
        }
    }, SPLASH_DISPLAY_DURATION);
}}

In styles.xml create a custom theme

<?xml version="1.0" encoding="utf-8"?><layer-list xmlns:android="http://schemas.android.com/apk/res/android">

<item
    android:drawable="@color/app_color"/>

<item>
    <bitmap
        android:gravity="center"
        android:src="@drawable/ic_in_app_logo_big"/>
</item></layer-list>

and finally in AndroidManifest.xml specify the theme to your activity

<style name="SplashTheme" parent="Theme.AppCompat.NoActionBar">
    <item name="android:windowBackground">@drawable/bg_splash</item>
</style>

Cheers.

Answer 13

您不会使用布局文件。而是将启动画面的背景指定为活动的主题背景。为此，首先在res / drawable中创建一个XML drawable。

注意：以下所有代码均可使用GitHub Link

<?xml version="1.0" encoding="utf-8"?>
<layer-list xmlns:android="http://schemas.android.com/apk/res/android">

    <item
        android:drawable="@color/gray"/>

    <item>
        <bitmap
            android:gravity="center"
            android:src="@mipmap/ic_launcher"/>
    </item>

</layer-list>

在这里，我设置了背景颜色和图像。

接下来，您将把它设置为主题中的启动活动的背景。导航到styles.xml文件并为启动活动添加新主题：

<resources>

    <!-- Base application theme. -->
    <style name="AppTheme" parent="Theme.AppCompat.Light.DarkActionBar">
        <!-- Customize your theme here. -->
    </style>

    <style name="SplashTheme" parent="Theme.AppCompat.NoActionBar">
        <item name="android:windowBackground">@drawable/background_splash</item>
    </style>

</resources>

在新的SplashTheme中，将窗口背景属性设置为XML drawable。在AndroidManifest.xml中将其配置为splash活动的主题：

<activity
    android:name=".SplashActivity"
    android:theme="@style/SplashTheme">
    <intent-filter>
        <action android:name="android.intent.action.MAIN" />

        <category android:name="android.intent.category.LAUNCHER" />
    </intent-filter>
</activity>

最后，您的SplashActivity课程应该转发您的主要活动：

public class SplashActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        Intent intent = new Intent(this, MainActivity.class);
        startActivity(intent);
        finish();
    }
}

请注意，您甚至没有为此SplashActivity设置视图。视图来自主题。在主题中为您的启动活动设置UI时，它会立即可用。

如果您的启动活动确实有一个布局文件，那么只有在您的应用程序完全初始化后，该布局文件才会对用户可见，这为时已晚。您希望在初始化应用程序之前，只在很短的时间内显示启动画面。

Answer 14

public class MainActivity extends Activity {

@Override

public void onCreate(Bundle savedInstanceState) {

    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    Thread t=new Thread()
    {

        public void run()
        {   

            try {

                sleep(2000);
                finish();
                Intent cv=new Intent(MainActivity.this,HomeScreen.class/*otherclass*/);
                startActivity(cv);
            } 

            catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    };
    t.start();
}

Answer 15

启动画面在Android中是一个不可用的对象：它无法尽快加载以隐藏主要活动开始的延迟。使用它有两个原因：广告和网络运营。

实施为对话框，可以毫不拖延地从启动画面跳转到活动的主UI。

public class SplashDialog extends Dialog {
    ImageView splashscreen;
    SplashLoader loader;
    int splashTime = 4000;

    public SplashDialog(Context context, int theme) {
        super(context, theme);
    }

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

        new Handler().postDelayed(new Runnable() {
            @Override
            public void run() {
                cancel();
            }
        }, splashTime);

    }
}

布局：

<?xml version="1.0" encoding="utf-8"?>

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:background="@color/white">

    <ImageView
        android:id="@+id/splashscreen"
        android:layout_width="190dp"
        android:layout_height="190dp"
        android:background="@drawable/whistle"
        android:layout_centerInParent="true" />

</RelativeLayout>

然后开始：

public class MyActivity extends ActionBarActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        if (getIntent().getCategories() != null &&  getIntent().getCategories().contains("android.intent.category.LAUNCHER")) {
            showSplashScreen();
        }
    }

    protected Dialog splashDialog;
    protected void showSplashScreen() {
        splashDialog = new SplashDialog(this, R.style.SplashScreen);
        splashDialog.show();
    }

    ...
}

Answer 16

启动画面示例：

public class MainActivity extends Activity {
    private ImageView splashImageView;
    boolean splashloading = false;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        splashImageView = new ImageView(this);
        splashImageView.setScaleType(ScaleType.FIT_XY);
        splashImageView.setImageResource(R.drawable.ic_launcher);
        setContentView(splashImageView);
        splashloading = true;
        Handler h = new Handler();
        h.postDelayed(new Runnable() {
            public void run() {
                splashloading = false;
                setContentView(R.layout.activity_main);
            }

        }, 3000);

    }

}

Answer 17

创建一个Activity，让我们将Activity命名为'A'，然后创建一个名为myscreen.xml的xml文件，在其中设置一个启动画面图像作为背景，然后使用倒计时器从一个Activtity导航到另一个。要知道如何使用倒数计时器，请在此问题TimerTask in Android?

中查看我的答案

Answer 18

真正简单＆gr8的方法：

首先使用以下网站创建启动画面：

https://www.norio.be/android-feature-graphic-generator/

选择徽标和口号，选择美丽的背景。将其尺寸调整为4096x4096。
现在下载该图片并将其升级为：

https://apetools.webprofusion.com/app/#/tools/imagegorilla

并生成所需的所有启动屏幕，所有设备，所有平台。

享受！

这里有足够的答案将对实施有所帮助。这篇文章旨在帮助其他人创建启动屏幕的第一步！

Answer 19

     - Add in SplashActivity 

   public class SplashActivity extends Activity {

       private ProgressBar progressBar;
       int i=0;
       Context context;
       private GoogleApiClient googleApiClient;

       @Override
       protected void onCreate(Bundle savedInstanceState) {
           super.onCreate(savedInstanceState);
           setContentView(R.layout.activity_splash);
           context = this;

           new Handler().postDelayed(new Runnable() {
               @Override
               public void run() {
                   startActivity(new Intent(Splash.this, LoginActivity.class));
                   finish();
               }
           }, 2000);

       }

   }

  - Add in activity_splash.xml

   <RelativeLayout
   xmlns:android="http://schemas.android.com/apk/res/android"
       xmlns:tools="http://schemas.android.com/tools"
       xmlns:custom="http://schemas.android.com/apk/res-auto"
       android:background="@color/colorAccent"
       android:layout_width="match_parent"
       android:layout_height="match_parent"
       tools:context=".Splash">

       <ImageView
           android:id="@+id/ivLogo"
           android:layout_width="match_parent"
           android:layout_height="match_parent"
           android:src="@mipmap/icon_splash"
           android:layout_centerHorizontal="true"
           android:layout_centerVertical="true"/>


       <ProgressBar
           android:id="@+id/circle_progress"
           style="?android:attr/progressBarStyleHorizontal"
           android:layout_width="fill_parent"
           android:layout_height="wrap_content"
           android:layout_alignParentBottom="true"
           android:layout_marginBottom="5dp"
           android:max="100"
           android:progressTint="@color/green"
           android:visibility="visible" />

   </RelativeLayout>

  - Add in AndroidManifest.xml

    <activity android:name="ex.com.SplashActivity">
               <intent-filter>
                   <action android:name="android.intent.action.MAIN" />

                   <category android:name="android.intent.category.LAUNCHER" />
               </intent-filter>
           </activity>

Answer 20

一种方法是通过创建FullScreenActivity / EmptyActivity（例如SplashScreenActivity）并将其设置为打开应用程序时显示的第一个Activity。在AndroidManifest.xml

中将以下内容添加到您的活动中

 <intent-filter>
        <action android:name="android.intent.action.MAIN" />
        <category android:name="android.intent.category.LAUNCHER" />
</intent-filter>

然后，您可以设置处理程序以在几秒钟后关闭此活动。

new Handler().postDelayed(new Runnable() {
            @Override
            public void run() {
                Intent i= new Intent(SplashScreenActivity.this,MainActivity.class);
                startActivity(i); //start new activity 
                finish();
            }
        }, 3000); //time in milliseconds

第二，如果您不希望创建单独的活动，则可以在MainActivity上扩大版式，并将布局可见性设置为 GONE 或在几毫秒后，主布局就会超过现有的初始屏幕布局。

Answer 21

这是我在启动画面上看到的最好的帖子：http://saulmm.github.io/avoding-android-cold-starts

SaúlMolinero为启动画面分为两个不同的选项：利用窗口背景为您的初始屏幕设置动画并显示占位符UI（这是Google目前用于大多数应用的热门选择）。

每次我需要考虑冷启动时间并避免因启动时间过长导致用户丢失时，我会参考这篇文章。

希望这有帮助！

Answer 22

虽然有很好的答案，但我会以谷歌推荐的方式展示：

1）首先为启动画面创建Theme：你有一个名为splashscreenTheme的主题，你的启动主题将是：

<style name="splashscreenTheme">
  <item name="android:windowBackground">@drawable/launch_screen</item>
</style>

注意：

android:windowBackground已经设置了您的闪屏图像需要再次在UI中执行此操作。

你也可以在这里使用颜色而不是drawable。

2）将主题设置为splashscreenActivity的显示

   <activity
            android:name=".activity.splashscreenActivity"
            android:screenOrientation="portrait"
            android:theme="@style/splashscreenTheme">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>

3）如果图片不小，请确保launch_screen drawable不在drawable文件夹中。

这将使启动屏幕启动更快，并使您从黑屏中保存

它还避免了额外的透支

Answer 23

有时用户打开SplashActivity并立即退出，但应用仍会在MainActivity之后转到SPLASH_SCREEN_DISPLAY_LENGTH。

为了防止它：在SplashActivity SplashActivity之前，您应该先检查MainActivity是否正在结束，然后再转到public class SplashActivity extends Activity { private final int SPLASH_SCREEN_DISPLAY_LENGTH = 2000; @Override public void onCreate(Bundle icicle) { ... new Handler().postDelayed(new Runnable() { @Override public void run() { if (!isFinishing()) {//isFinishing(): If the activity is finishing, returns true; else returns false. startActivity(new Intent(SplashActivity.this, MainActivity.class)); finish(); } }, SPLASH_SCREEN_DISPLAY_LENGTH); } } }

<?php

$fileName = $_GET['fileNameData'];
$htmlImport = $_GET['htmlToSaveData'];

$htmlToSave = (string)$htmlImport;

$myFile = fopen($fileName, "w") or die('You do not have write permissions');

//fwrite($myFile, $htmlToSave);
file_put_contents($myFile, $htmlToSave); 
fclose($myFile);

?>

希望这个帮助

Answer 24

使用CountDownTimer

实现另一种方法

@Override
public void onCreate(Bundle savedInstanceState) {
     super.onCreate(savedInstanceState);
     setContentView(R.layout.splashscreen);

 new CountDownTimer(5000, 1000) { //5 seconds
      public void onTick(long millisUntilFinished) {
          mTextField.setText("seconds remaining: " + millisUntilFinished / 1000);
      }

     public void onFinish() {
          startActivity(new Intent(SplashActivity.this, MainActivity.class));
          finish();
     }

  }.start();
}

Answer 25

超灵活的启动屏幕如何使用相同的代码并在AndroidManifest.xml中定义，因此代码永远不需要更改。我通常开发代码库，不喜欢自定义代码，因为它很草率。

<activity
        android:name=".SplashActivity">
        <intent-filter>
            <action android:name="android.intent.action.MAIN" />
            <category android:name="android.intent.category.LAUNCHER" />
        </intent-filter>
        <meta-data android:name="launch_class" android:value="com.mypackage.MyFirstActivity" />
        <meta-data android:name="duration" android:value="5000" />
</activity>

然后，SpashActivity本身会查找＆＃34; launch_class＆＃34;的元数据。然后制作意图本身。元数据＆＃34;持续时间＆＃34;定义启动画面停留的时间。

public class SplashActivity extends Activity {

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

    ComponentName componentName = new ComponentName(this, this.getClass());

    try {
        Bundle bundle = null;
        bundle = getPackageManager().getActivityInfo(componentName, PackageManager.GET_META_DATA).metaData;
        String launch_class = bundle.getString("launch_class");
        //default of 2 seconds, otherwise defined in manifest
        int duration = bundle.getInt("duration", 2000);

        if(launch_class != null) {
            try {
                final Class<?> c = Class.forName(launch_class);

                new Handler().postDelayed(new Runnable() {
                    @Override
                    public void run() {
                        Intent intent = new Intent(SplashActivity.this, c);
                        startActivity(intent);
                        finish();
                    }
                }, duration);

            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
        }
    } catch (PackageManager.NameNotFoundException e) {
        e.printStackTrace();
    }
  }
}

Answer 26

简单代码，它有效：） 简单的启动

input

Answer 27

public class SplashActivity extends Activity {

  Context ctx;

  @Override
  protected void onCreate(Bundle savedInstanceState) {
      super.onCreate(savedInstanceState);
      ctx = this;
      setContentView(R.layout.activity_splash);

      Thread thread = new Thread(){
          public void run(){
              try {
                  sleep(3000);
              } catch (InterruptedException e) {
                  e.printStackTrace();
              }

              Intent in = new Intent(ctx,MainActivity.class);
              startActivity(in);
              finish();
          }
      };
      thread.start();
  }
}

Answer 28

在我的情况下，我不想创建一个新的Activity只显示2秒的图像。启动我的MainAvtivity时，使用毕加索将图像加载到持有者中，我知道加载大约需要1秒钟，所以我决定在我的MainActivity OnCreate中执行以下操作：

splashImage = (ImageView) findViewById(R.id.spllll);

    this.getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,WindowManager.LayoutParams.FLAG_FULLSCREEN);

    int secondsDelayed = 1;
    new Handler().postDelayed(new Runnable() {
        public void run() {
            getWindow().clearFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN);
            splashImage.setVisibility(View.GONE);

        }
    }, secondsDelayed * 2000);

启动应用程序时，首先发生的是显示ImageView，并通过将窗口标志设置为全屏来删除statusBar。然后我使用Handler运行2秒，2秒后我清除全屏标志并设置ImageView到GONE的可见性。简单，有效。

Answer 29

我使用线程在android中制作Flash屏幕。

    import android.content.Intent;
import android.os.Bundle;
import android.support.annotation.Nullable;
import android.support.v7.app.AppCompatActivity;

public class HomeScreen extends AppCompatActivity{
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.screen_home);

        Thread thread = new Thread(){
            public void run(){
                try {
                    Thread.sleep(3 * 1000);
                    Intent i = new Intent(HomeScreen.this, MainActivity.class);
                    startActivity(i);
                } catch (InterruptedException e) {
                }
            }
        };
        thread.start();
    }
}

Answer 30

它在android中非常简单，我们只使用处理程序概念来实现启动画面

在 SplashScreenActivity java文件中粘贴此代码。

在 SplashScreenActivity xml文件中使用imageview放置任何图片。

public void LoadScreen() {
        final Handler handler = new Handler();
        handler.postDelayed(new Runnable() {
            @Override
            public void run() {                 
                Intent i = new Intent(SplashScreenActivity.this, AgilanbuGameOptionsActivity.class);
                startActivity(i);
            }
        }, 2000);
    }

Answer 31

您可以在onCreate方法中添加它

new Handler().postDelayed(new Runnable() {
                @Override
                public void run() {
                    // going to next activity
                    Intent i=new Intent(SplashScreenActivity.this,MainActivity.class);
                    startActivity(i);
                    finish();
                }
            },time);

然后根据需要初始化以毫秒为单位的时间值...

private  static int time=5000;

有关更多详细信息，请从此链接下载完整代码...

https://github.com/Mr-Perfectt/Splash-Screen

Answer 32

在Kotlin中编写以下代码：-

 Handler().postDelayed({
            val mainIntent = Intent(this@SplashActivity, LoginActivity::class.java)
            startActivity(mainIntent)
            finish()
        }, 500)

希望这会对您有所帮助。谢谢........

Answer 33

这是一个简单的！

〜Lunox

MainActivity.java

package com.example.splashscreen;

import androidx.appcompat.app.AppCompatActivity;
import android.os.Bundle;

public class MainActivity extends AppCompatActivity {

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

splashscreen.java

package com.example.splashscreen;

import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.os.Handler;

public class splashscreen extends Activity {
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.splashscreen);

        //Splash Screen duration
        int secondsDelayed = 1;
        new Handler().postDelayed(new Runnable() {
            public void run() {
                startActivity(new Intent(splashscreen.this, MainActivity.class));
                finish();
            }
        }, secondsDelayed * 3000);
    }
}

activity_main.xml

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Hello World!"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintLeft_toLeftOf="parent"
        app:layout_constraintRight_toRightOf="parent"
        app:layout_constraintTop_toTopOf="parent" />

</androidx.constraintlayout.widget.ConstraintLayout>

splashscreen.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical" android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:background="@drawable/splashlogo"

    />

splashlogo.png

splashlogo.png

GitHub

SplashScreen

如何制作闪屏？

33 个答案: