如何制作启动画面?

我想让我的应用看起来更专业，所以我决定添加一个启动画面。

我应该如何进行实现呢?

831003 次浏览
小开
  • 创建一个活动: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);
}
}

  • change ActivityB.class to whichever activity you want to start after the splash screen

  • check your manifest file and it should look like 

        <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>
小开

创建一个活动，让我们活动命名为“a”，然后创建一个名为mysscreen .xml的xml文件，在其中设置一个启动画面图像作为背景，然后使用倒计时计时器从一个活动导航到另一个活动。要知道如何使用倒数计时器，请参阅我在这个问题TimerTask在Android?中的回答

小开
最佳答案

进一步阅读:

旧的回答:

# EYZ0: # EYZ1

这个答案会告诉你如何在应用启动时固定时间显示启动画面。例如，你可以选择显示3秒的启动画面。然而，如果你想要在可变的时间内(例如应用启动时间)显示飞溅屏幕，你应该看看Abdullah的答案https://stackoverflow.com/a/15832037/401025。但是要注意，应用程序在新设备上的启动速度可能非常快，所以用户只会看到一个flash，这是糟糕的用户体验。

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

  <?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);
}
}

就这些;)

小开

  1. 创建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();
}
}

  2. splashscreen.xml will be like this

    <?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>
小开 
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();
}
小开

启动画面的延迟取决于应用程序的启动时间。

当你打开任何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);
}

<强>更新 查看这篇文章.

感谢@mat1h和@adelriosantiago

小开

在默认情况下，启动屏幕不会自动使你的应用程序看起来更专业。一个专业设计的启动画面有可能使你的应用程序看起来更专业，但如果你不知道如何编写一个启动画面，那么你的应用程序的其他部分又会有多专业呢?

设置启动画面的唯一原因(借口)是你要做大量的计算，或者等待GPS/WiFi启动，因为你的应用程序在启动之前依赖于这些。如果没有这些计算的结果或访问GPS/WiFi(等等)，你的应用程序是死在水里的，因此你觉得你需要一个启动画面，并且必须阻止任何其他正在运行的程序(包括后台)的屏幕视图。

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

最好允许用户(和操作系统的其他部分)在等待的时候做一些其他的事情，而不是把你的程序设计成依赖于一些需要一段时间的事情(当等待的持续时间是不确定的)。

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

如果你必须等待这些计算或GPS/WiFi，最好是简单地让应用程序启动，并有一个弹出窗口，告诉你需要等待计算(一个TEXTUAL的“初始化”消息是可以的)。GPS/WiFi的等待是预期的(如果它们没有在另一个程序中启用)，所以宣布他们的等待时间是不必要的。

请记住，当启动屏幕启动时，你的程序实际上已经在运行，你所做的只是延迟程序的使用，并占用CPU/GPU来做一些大多数人认为没有必要的事情。

我们最好真的想要等待和看到你的启动屏幕，每次我们开始你的程序，否则我们不会觉得这是非常专业的编写。将启动画面设置为全屏，并复制实际程序的屏幕(所以我们认为它是初始化的，但实际上它并没有初始化)可能会实现你的目标(让你的程序看起来更专业)，但我不敢打赌这一点。

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

如何做到:https://encrypted.google.com/search?q=Android+splash+screen+source

所以有一个很好的理由不这样做，但如果你确定你的情况在某种程度上超出了这些例子，那么这样做的方法是上面给出的。一定要让你的申请看起来更专业，否则你就失去了这么做的唯一理由。

它就像一个YouTube频道，每个视频都以冗长的图形介绍(和outo)开始，或者觉得有必要讲一个笑话或解释过去一周发生的事情(当它不是喜剧或生活方式频道时)。秀一秀吧!(只需运行程序)。

小开

启动画面示例:

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);


}


}
小开

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

  1. 启动屏幕是我的应用程序的入口点，所以在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>

  2. The splash screen should only show once in the app life cycle, I use a boolean variable to record the state of the splash screen, and only show it on the first time.

    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();
}
}
}

happy coding!

小开

在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();
}


...
}
小开

一个超级灵活的启动屏幕如何，可以使用相同的代码，并在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本身查找“launch_class”的元数据，然后创建Intent本身。元数据“持续时间”定义了启动画面持续的时间。

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();
}
}
}
小开

这是完整的代码

SplashActivity.java

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);
}}

在绘图中创建bg_splash.xml

<?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>

在styles.xml中创建一个自定义主题

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

最后在AndroidManifest.xml中指定活动的主题

<activity
android:name=".activities.SplashActivity"
android:label="@string/app_name"
android:screenOrientation="portrait"
android:theme="@style/SplashTheme">
<intent-filter>
<action android:name="android.intent.action.MAIN" />


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

欢呼。

小开
以上所有的答案都非常好。但是存在内存泄漏的问题。 这个问题在Android社区中通常被称为“泄露活动”。这到底是什么意思呢?< / p >

当配置发生变化时，比如方向变化，Android会销毁Activity并重新创建它。通常，垃圾收集器只会清除旧Activity实例的已分配内存，一切正常。

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

如何判断应用程序是否泄漏内存?最快的方法是在Android Studio中打开内存选项卡，并在改变方向时注意分配的内存。 如果分配的内存一直在增加而不减少，那么你就有内存泄漏 < p > 1。当用户改变方向时内存泄漏。 # EYZ0 < / p >

首先，你需要在布局资源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;
}
}

更多信息请浏览链接

小开

另一种方法是使用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();
}
小开

有时用户打开SplashActivity并立即退出，但应用程序仍然转到SPLASH_SCREEN_DISPLAY_LENGTH后的MainActivity。

为了防止它:在SplashActivity中，你应该在移动到MainActivity之前检查SplashActivity是否完成

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);
}
}
}

希望这对你有所帮助

小开

虽然有很好的答案，但我将展示谷歌推荐的方法:

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

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

注意:

android:windowBackground已经设置你的溅屏图像不
需要在UI中再次这样做。

你也可以在这里使用颜色来代替绘图。

2)设置主题为splashscreenActivity的manifest

   <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文件夹，如果你的图像不小。

这将导致更快的启动屏幕启动和拯救你从黑屏

这也避免了额外的透支

小开

这是我所见过的关于启动画面的最佳帖子:http://saulmm.github.io/avoding-android-cold-starts

Saúl Molinero介绍了两种不同的启动画面选项:利用窗口背景动画进入初始屏幕和显示占位符UI(这是谷歌目前在大多数应用程序中使用的流行选择)。

每当我需要考虑冷启动时间和避免由于长启动时间而导致用户流失时，我都会参考这篇文章。

希望这能有所帮助!

小开

阿卜杜拉的回答很好。但我想在我的回答中补充一些细节。

实现启动画面

正确执行闪屏的方法与你想象的略有不同。您所看到的splash视图必须立即准备好，甚至在您可以在splash活动中膨胀布局文件之前。

所以你不会使用布局文件。相反，指定启动画面的背景作为活动的主题背景。为此，首先在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">
<!-- Background Color -->
<item
android:drawable="@color/gray"/>


<!-- Logo -->
<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>

这个主题将没有动作栏和我们刚才创建的背景。

在manifest中，你需要将SplashTheme设置为你想要用作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>

然后在你的活动代码中，使用意图引导用户进入特定的屏幕。

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://material.google.com/patterns/launch-screens.html
  2. https://www.bignerdranch.com/blog/splash-screens-the-right-way/ 感谢这些人把我推向正确的方向。我想帮助别人，因为公认的答案是不建议做闪屏
小开

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

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

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

简而言之:

在manifest中声明你的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();


}

接下来创建主题背景窗口的资源:

<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>
小开

在Android 棉花糖之后，我想到的另一个有效使用启动画面的方法是应用启动画面中的请求必要的Android Permissions。

似乎大多数应用程序都是这样处理权限请求的。

  • 对话框是糟糕的ui，它们破坏了主要流程，让你决定运行时间，事实上，大多数用户甚至可能不在乎你的应用程序是否想在SD卡上写东西。他们中的一些人甚至不明白我们试图传达什么，直到我们用简单的英语翻译出来。

  • 一次请求权限可以减少每次操作前的“if else”次数，使代码看起来不那么杂乱。

这是一个例子，你可以在你的splash活动中请求运行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);
}




}
小开

# EYZ0 # EYZ1

int secondsDelayed = 1;
new Handler().postDelayed(new Runnable() {
public void run() {
startActivity(new Intent(LoginSuccessFull.this, LoginActivity.class));
finish();
}
}, secondsDelayed * 1500);
小开 
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();
}
}
小开

在我的例子中，我不想创建一个新的活动只是为了显示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，并通过将窗口标志设置为全屏来删除状态栏。然后我使用Handler运行2秒，2秒后我清除全屏标志，并将ImageView的可见性设置为GONE。简单，简单，有效。

小开

我在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();
}
}
小开 
     - 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>
小开

它真的很简单，在安卓，我们只是使用处理器的概念来实现启动画面

在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);
}
小开

真的很简单&Gr8方法:

享受吧!

这里有足够的答案，将有助于实施。这篇文章旨在帮助其他人完成创建启动画面的第一步!

小开

你可以在你的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

小开

在Kotlin中编写以下代码:-

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

希望这对你有所帮助，谢谢........

小开

这里有一个简单的!

~ 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 .png

GitHub

SplashScreen

小开

一种方法是通过创建FullScreenActivity/EmptyActivity(例如SplashScreenActivity)，并将其设置为打开应用程序时显示的第一个活动

 <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，或者在几毫秒后在现有的启动画面布局上膨胀主布局。


提交答案