스플래시 화면을 만들려면 어떻게합니까?

앱을보다 전문적으로 보이게 만들고 싶기 때문에 스플래시 화면을 만들고 싶다고 결정했습니다.

어떻게 만들고 구현할 수 있습니까?

더 읽을 거리 :

• 앱 시작 시간 및 테마 시작 화면 (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);
    }
}

그게 다야 ;)

이 솔루션을 사용하면 사용자가 더 기다리지 않아도됩니다 . 시작 화면의 지연은 응용 프로그램의 시작 시간에 따라 다릅니다.

안드로이드 앱을 열면 기본적으로 앱의 제목과 아이콘이있는 검은 화면이 표시됩니다. 스타일 / 테마를 사용하여 변경할 수 있습니다.

먼저 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 덕분에

• 활동 만들기 : 스플래시
• 레이아웃 XML 파일 만들기 : splash.xml
• splash.xml 레이아웃에 UI 구성 요소를 배치하여 원하는 방식으로 표시

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

위의 답변은 매우 좋지만 다른 것을 추가하고 싶습니다. 나는 안드로이드를 처음 접했고 개발하는 동안 이러한 문제를 만났다. 이것이 나와 같은 사람을 도울 수 있기를 바랍니다.

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를 절대 기다려야하는 경우 간단히 응용 프로그램을 시작하고 계산을 기다려야한다는 팝업이 표시되는 것이 가장 좋습니다 (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

따라서 그것을하지 않는 좋은 이유가 있지만 어떻게 든 상황이 그 예를 벗어난 것이 확실하다면 그 방법을 위에 제시합니다. 실제로 응용 프로그램을보다 전문적으로 보이게 만들거나 당신이 이것을 한 유일한 이유를 물리 쳤는지 확인하십시오.

길이가 긴 그래픽 소개 (및 Outro)로 모든 동영상을 시작하거나 지난 주 동안 코미디 나 라이프 스타일 채널이 아닌 경우 일어난 일을 농담에게 말하거나 설명해야 할 필요성을 느끼는 YouTube 채널과 같습니다. 쇼를 보여주세요! (그냥 프로그램을 실행하십시오).

무엇보다도 모든 답변이 정말 좋습니다. 그러나 메모리 누수 문제가 발생합니다. 이 문제는 종종 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;
    }
}

자세한 내용은이 링크 를 참조하십시오

불필요하게 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 카드에 무언가를 쓰려고해도 신경 쓰지 않을 것입니다. 그들 중 일부는 평범한 영어로 번역 할 때까지 우리가 전달하려고하는 것을 이해하지 못할 수도 있습니다.

• 한 번에 권한을 요청하면 모든 작업 전에 "필요한 경우"수가 줄어들고 코드가 복잡해 보이지 않습니다.

Android OS 23 이상을 실행하는 기기의 스플래시 활동에 권한을 요청하는 방법의 예입니다.

모든 권한이 부여되었거나 이미 부여되었거나 OR Marshmallow에서 앱이 실행 중이면 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 링크에서 사용할 수 있습니다

<?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에서 사용할 수없는 약간의 개체입니다. 주요 활동 시작 지연을 숨기기 위해 가능한 빨리로드 할 수 없습니다. 광고와 네트워크 운영이라는 두 가지 이유가 있습니다.

대화 상자로 구현하면 스플래시 화면에서 활동의 기본 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 접근 방식 :

• 먼저 다음 웹 사이트에서 스플래시를 만드십시오.

  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) 먼저 Theme시작 화면 만들기 :이라는 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úl Molinero는 스플래시 화면을위한 두 가지 다른 옵션을 사용합니다. 창 배경을 활용하여 초기 화면에 애니메이션을 적용하고 자리 표시 자 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것은 표시되며 윈도우 플래그를 전체 화면으로 설정하여 statusBar가 제거됩니다. 그런 다음 Handler2 초 동안 a 를 사용하여 2 초 후에 전체 화면 플래그를 지우고의 가시성을로 설정 ImageView했습니다 GONE. 쉽고 간단하며 효과적입니다.

안드로이드에서 우리는 스플래시 화면을 구현하기 위해 핸들러 개념을 사용합니다.

당신에 SplashScreenActivity 자바 파일 이 코드를 붙여 넣습니다.

당신에 SplashScreenActivity XML 파일 이미지 뷰를 사용하는 사진을 넣어.

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