スプラッシュスクリーンを作成するにはどうすればよいですか？

アプリをよりプロフェッショナルに見せたかったので、スプラッシュスクリーンを作成することにしました。

それをどのように作成して実装しますか？

参考文献：

• アプリの起動時間とテーマの起動画面（Android Performance Patterns Season 6 Ep。4）
• Androidのスプラッシュスクリーン：正しい方法

古い答え：

方法：シンプルなスプラッシュスクリーン

この答えは、ブランド化などの理由でアプリが起動したときに、スプラッシュスクリーンを一定時間表示する方法を示しています。たとえば、スプラッシュ画面を3秒間表示するように選択できます。ただし、さまざまな時間（たとえば、アプリの起動時間）のspash画面を表示する場合は、Abdullahの回答https://stackoverflow.com/a/15832037/401025を確認する必要があります。ただし、新しいデバイスではアプリの起動が非常に高速になる可能性があるため、ユーザーにはUXの悪いフラッシュしか表示されないことに注意してください。

最初に、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);
    }
}

それで全部です ;）

このソリューションでは、ユーザーがこれ以上待つことができないことに注意してください。スプラッシュスクリーンの遅延は、アプリケーションの起動時間に依存します。

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

3番目に、onCreate（）起動アクティビティでテーマを更新します。

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

更新この投稿を チェックしてください。

@ mat1hと@adelriosantiagoに感謝

• アクティビティを作成する：スプラッシュ
• レイアウト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>

上記の回答は非常に良いですが、何か他のものを追加したいと思います。私は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. スプラッシュスクリーンはアプリのライフサイクルで一度だけ表示されるはずです。ブール変数を使用してスプラッシュスクリーンの状態を記録し、初めて表示するだけです。

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

幸せなコーディング！

アブドラの答えは素晴らしいです。しかし、私は私の答えでいくつかの詳細を追加したいと思います。

スプラッシュスクリーンの実装

スプラッシュスクリーンの正しい実装方法は、想像するよりも少し異なります。表示されるスプラッシュビューは、スプラッシュアクティビティでレイアウトファイルをインフレートできるようになる前でも、すぐに準備する必要があります。

したがって、レイアウトファイルは使用しません。代わりに、スプラッシュスクリーンの背景をアクティビティのテーマの背景として指定します。これを行うには、まずres / drawableにXMLドローアブルを作成します。

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

それが正しい方法です。私はこれらのリファレンスを回答に使用しました。

1. https://material.google.com/patterns/launch-screens.html
2. https://www.bignerdranch.com/blog/splash-screens-the-right-way/ 私を正しい方向に向かわせてくれたこれらの人たちに感謝します。受け入れられた回答はスプラッシュスクリーンを実行することをお勧めしませんので、私は他の人を助けたいと思います。

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 このようになります

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

Splash Scrennは、デフォルトでは、アプリケーションをより専門的に見せることはしません。専門的に設計されたスプラッシュスクリーンは、アプリケーションをより専門的に見せることができますが、作成方法がわからない場合は、アプリケーションの残りの部分が実際にどの程度プロフェッショナルになるかを考えてください。

スプラッシュ画面が表示される唯一の理由（言い訳）は、大量の計算を行っているか、アプリケーションが起動する前にそれに依存しているためにGPS / WiFiが起動するのを待っているためです。これらの計算の結果またはGPS / WiFi（など）へのアクセスがない場合、アプリケーションは水中で停止しているため、スプラッシュ画面が必要であると感じ、他の実行中のプログラム（背景を含む）の画面の表示をブロックする必要があります。 ）。

このようなスプラッシュスクリーンは、フルスクリーンアプリケーションのように見え、すでに初期化されているように見えるはずです。その後、長い計算が完了した後、最終的な詳細を入力できます（画像を調整します）。チャンスそれが事実である、またはそれがあることを唯一の方法プログラムを設計することができるの強大な小さいです。

しばらく時間がかかるものに依存するようにプログラムを設計するよりも、ユーザー（およびOSの残りの部分）が待機中に他のことを実行できるようにした方がよいでしょう（待機期間が不明な場合）。

GPS / WiFiが起動していることを示すアイコンがすでに電話にあります。スプラッシュスクリーンが占める時間またはスペースは、事前計算のロードまたは実際の計算に費やされる可能性があります。作成する問題と考慮すべき事項については、以下の最初のリンクを参照してください。

これらの計算またはGPS / WiFiを絶対に待つ必要がある場合は、アプリケーションを起動して、計算を待つ必要があることを示すポップアップを表示するのが最善です（テキストの「初期化中」のメッセージで問題ありません）。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

したがって、それを行わないことには十分な理由がありますが、何らかの理由で状況がこれらの例の外にあることが確実である場合は、それを行うための手段が上記に示されています。それが本当にあなたのアプリケーションをよりプロフェッショナルに見えるようにするか、あなたがこれを行うために与えた唯一の理由を打ち負かしたことを確認してください。

それは、すべての動画を長いグラフィックイントロ（およびアウトロ）で開始する、または過去1週間（コメディチャネルまたはライフスタイルチャネルではない場合）に何が起こったかをジョークに伝えたり説明したりする必要があると感じているYouTubeチャネルのようなものです。ただショーを見せてください！（プログラムを実行するだけです）。

上記のすべての答えは本当にとても良いです。しかし、メモリリークの問題が発生しています。この問題は、Androidコミュニティでは「アクティビティの漏洩」としてよく知られています。これはどういう意味ですか？

方向の変更などの構成変更が発生すると、Androidはアクティビティを破棄して再作成します。通常、ガベージコレクターは古いアクティビティインスタンスに割り当てられたメモリをクリアするだけで、問題はありません。

「アクティビティのリーク」とは、古いインスタンスに割り当てられたメモリがアクティビティインスタンスに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;
    }
}

詳細については、このリンクをご覧ください

4から5のスプラッシュ画面での停止は、不必要に意味をなさない。バックグラウンドで何かをロードする場合は問題ありません。スプラッシュスクリーンを実装するためにこのアプローチに従います 。-スプラッシュスクリーンを正しく実装することは、想像するよりも少し異なります。表示されるスプラッシュビューは、スプラッシュアクティビティでレイアウトファイルをインフレートできるようになる前でも、すぐに準備する必要があります。

したがって、レイアウトファイルは使用しません。代わりに、スプラッシュスクリーンの背景をアクティビティのテーマの背景として指定します。これを行うには、まず、res / drawableに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ファイルに移動し、スプラッシュアクティビティの新しいテーマを追加します。

<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ドローアブルに設定します。これをAndroidManifest.xmlのスプラッシュアクティビティのテーマとして構成します。

<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

これはここに完全なコードです

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>

乾杯。

スプラッシュスクリーンは、レイアウトファイルからロードしないでください。ロードするときに多少の遅延が生じる可能性があります。

最良の方法は、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();

}

次に、テーマの背景ウィンドウのリソースを作成します。

<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 Marshmallowの後、私が思いついた他のスプラッシュスクリーンの生産的な使用は、アプリのスプラッシュスクリーンで必要Android Permissionsであると要求しています。

ほとんどのアプリは許可リクエストをこのように処理するようです。

• ダイアログはUIXを悪くし、メインフローを中断させ、ランタイムを決定させます。ほとんどのユーザーは、アプリがSDカードに何かを書きたいかどうかさえ気にしないかもしれません。彼らの何人かは、私たちがそれを平易な英語に翻訳するまで、私たちが伝えようとしていることさえ理解していないかもしれません。

• 一度に権限を要求すると、すべての操作の前に「if else」の数が減り、コードが乱雑に見えなくなります。

これは、Android OS 23以降を実行しているデバイスのスプラッシュアクティビティで権限を要求する方法の例です。

すべての権限が付与されている場合、または既に付与されている場合、またはアプリがプレマシュマロで実行されている場合は、ユーザーがこのコンテンツを読んで最善を尽くそうと努力したことに感謝できるように、わずか0.5秒の遅延でメインコンテンツを表示します。

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


}

レイアウトファイルは使用しません。代わりに、スプラッシュスクリーンの背景をアクティビティのテーマの背景として指定します。これを行うには、まずres / drawableにXMLドローアブルを作成します。

注：以下のコードはすべて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ドローアブルに設定します。これをAndroidManifest.xmlのスプラッシュアクティビティのテーマとして構成します。

<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を設定すると、すぐに使用できます。

スプラッシュアクティビティ用のレイアウトファイルがある場合、そのレイアウトファイルは、アプリが完全に初期化された後でないとユーザーに表示されず、手遅れです。アプリが初期化されるまでの短い時間にのみスプラッシュを表示したいとします。

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

アクティビティを作成し、「A」という名前のアクティビティを作成してから、スプラッシュスクリーン画像を背景として設定するmyscreen.xmlというxmlファイルを作成し、カウントダウンタイマーを使用して、あるアクティビティから別のアクティビティに移動します。カウントダウンタイマーの使用方法を知るには、この質問のAndroidのTimerTaskの回答を参照してください。

スプラッシュ画面の例：

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では少し使用できないオブジェクトです。メインアクティビティの開始の遅延を隠すために、できるだけ早くロードすることはできません。これを使用する理由は2つあります。広告とネットワーク操作です。

ダイアログとして実装すると、スプラッシュ画面からアクティビティのメイン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();
    }

    ...
}

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

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

本当に簡単＆GR8のアプローチ：

• まず、次のWebサイトでスプラッシュを作成します。

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

  ロゴとスローガンを選択し、美しい背景を選択します。4096x4096にサイズ変更します。

• 次に、その画像をダウンロードして、次のように更新します。

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

  そして、必要なすべてのスプラッシュ画面、すべてのデバイス、すべてのプラットフォームを生成します。

楽しい！

実装に役立つ十分な回答がここにあります。この投稿は、スプラッシュスクリーンを作成する最初のステップで他のユーザーを支援することを目的としています。

同じコードを使用でき、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」のメタデータを検索して、インテント自体を作成します。メタデータの「期間」は、スプラッシュ画面が持続する時間を定義します。

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すぐに終了することがありますが、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);
        }                             
   }                                
}

この助けを願っています

良い答えはありますが、Googleが推奨する方法を示します。

1）最初にThemeforスプラッシュ画面を作成します。というテーマがsplashscreenThemeあり、ランチャーのテーマは次のようになります。

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

注意：

android:windowBackgroundすでに
UIでスプラッシュスクリーン画像を設定する必要はありません。

ドローアブルの代わりに色を使用することもできます。

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）画像が小さくない場合drawableは、launch_screen がdrawableフォルダーにないことを確認してください。

起動画面の起動が速くなり、黒い画面からあなたを救います

また、余分なオーバードローを回避します

これは、スプラッシュスクリーンで見た中で最高の投稿です。http：//saulmm.github.io/avoding-android-cold-starts

SaúlMolineroは、スプラッシュスクリーンの2つの異なるオプションを使用します。ウィンドウの背景を利用して、初期画面にアニメーションを表示することと、プレースホルダーUIを表示することです（これは、Googleが最近のほとんどのアプリで使用している一般的な選択肢です）。

コールドスタート時間を考慮する必要があり、起動時間が長いことによるユーザーのドロップオフを回避する必要があるたびに、この投稿を参照します。

お役に立てれば！

私の場合、画像を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では本当にシンプルで、ハンドラーの概念を使用してスプラッシュスクリーンを実装します

あなたの中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);
    }

これを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)

これがあなたに役立つことを願っています。ありがとう........

シンプルなコード、それは動作します:) シンプルなスプラッシュ

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