Làm thế nào để tôi thực hiện một màn hình giật gân?

Tôi muốn làm cho ứng dụng của mình trông chuyên nghiệp hơn, vì vậy tôi quyết định rằng tôi muốn tạo một màn hình giật gân.

Làm thế nào tôi có thể tạo ra nó và sau đó thực hiện nó?

Đọc thêm:

• Thời gian khởi chạy ứng dụng & màn hình khởi chạy theo chủ đề (Mẫu hiệu suất Android Phần 6 Ep 4)
• Màn hình Splash trong Android: Đúng cách

Câu trả lời cũ:

CÁCH : Màn hình giật gân đơn giản

Câu trả lời này cho bạn thấy cách hiển thị màn hình giật gân trong một khoảng thời gian cố định khi ứng dụng của bạn bắt đầu vì lý do thương hiệu. Ví dụ: bạn có thể chọn hiển thị màn hình giật gân trong 3 giây. Tuy nhiên, nếu bạn muốn hiển thị màn hình spash trong một khoảng thời gian khác nhau (ví dụ: thời gian khởi động ứng dụng), bạn nên xem câu trả lời của Abdullah https://stackoverflow.com/a/15832037/401025 . Tuy nhiên, hãy lưu ý rằng khởi động ứng dụng có thể rất nhanh trên các thiết bị mới, vì vậy người dùng sẽ chỉ nhìn thấy đèn flash UX xấu.

Trước tiên, bạn cần xác định màn hình spash trong layout.xmltệp của bạn

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

Và hoạt động của bạn:

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

Đó là tất cả ;)

Lưu ý giải pháp này sẽ không để người dùng chờ thêm: độ trễ của màn hình giật gân phụ thuộc vào thời gian khởi động của ứng dụng.

Khi bạn mở bất kỳ ứng dụng Android nào, bạn sẽ nhận được một số màn hình đen với tiêu đề và biểu tượng của ứng dụng trên đầu trang, bạn có thể thay đổi điều đó bằng cách sử dụng một kiểu / chủ đề.

Đầu tiên, tạo một tệp style.xml trong thư mục giá trị và thêm một kiểu cho nó.

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

Thay vì sử dụng, @android:style/Theme.DeviceDefault.Light.NoActionBarbạn có thể sử dụng bất kỳ chủ đề nào khác làm cha mẹ.

Thứ hai, trong ứng dụng Manifest.xml android:theme="@style/splashScreenTheme"của bạn thêm vào hoạt động chính của bạn.

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

Thứ ba, Cập nhật chủ đề của bạn trong hoạt động khởi chạy onCreate () của bạn.

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

CẬP NHẬT Kiểm tra bài này .

Cảm ơn @ mat1h và @adelriosantiago

• Tạo một hoạt động: Splash
• Tạo một tệp XML bố cục: Splash.xml
• Đặt các thành phần UI trong bố cục Splash.xml để nó trông như bạn muốn

• Splash.java của bạn có thể trông như thế này:

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

• thay đổi ActivityB.classbất kỳ hoạt động nào bạn muốn bắt đầu sau màn hình giật gân

• kiểm tra tệp kê khai của bạn và nó sẽ trông giống như

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

Các câu trả lời ở trên là rất tốt, nhưng tôi muốn thêm một cái gì đó khác. Tôi mới sử dụng Android, tôi đã gặp những vấn đề này trong quá trình phát triển của mình. hy vọng điều này có thể giúp một người như tôi.

1. Màn hình Splash là điểm vào của ứng dụng của tôi, vì vậy hãy thêm các dòng sau vào 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. Màn hình giật gân chỉ nên hiển thị một lần trong vòng đời ứng dụng, tôi sử dụng biến boolean để ghi lại trạng thái của màn hình giật gân và chỉ hiển thị lần đầu tiên.

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

hạnh phúc mã hóa!

Câu trả lời của Abdullah là tuyệt vời. Nhưng tôi muốn thêm một số chi tiết cho nó với câu trả lời của tôi.

Triển khai màn hình Splash

Thực hiện một màn hình giật gân đúng cách là một chút khác biệt so với bạn có thể tưởng tượng. Chế độ xem giật gân mà bạn thấy phải sẵn sàng ngay lập tức, ngay cả trước khi bạn có thể thổi phồng tệp bố cục trong hoạt động giật gân của mình.

Vì vậy, bạn sẽ không sử dụng một tập tin bố trí. Thay vào đó, chỉ định nền màn hình giật gân của bạn làm nền chủ đề của hoạt động. Để làm điều này, trước tiên hãy tạo một XML có thể vẽ được trong res / drawable.

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

Nó chỉ là một danh sách lớp với logo trong màu nền trung tâm với nó.

Bây giờ hãy mở tệp kiểu tệp và thêm kiểu này

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

Chủ đề này sẽ phải có thanh hành động và với nền mà chúng ta vừa tạo ở trên.

Và trong bảng kê khai, bạn cần đặt SplashTheme thành hoạt động mà bạn muốn sử dụng làm trò giật gân.

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

Sau đó, bên trong mã hoạt động của bạn điều hướng người dùng đến màn hình cụ thể sau khi sử dụng ý định.

public class SplashActivity extends AppCompatActivity {

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

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

Đó là cách đúng đắn để làm. Tôi đã sử dụng các tài liệu tham khảo để trả lời.

1. https: // m vật liệu mô hình chính
2. https://www.bignerdranch.com/blog/Station-screen-the-right-way/ Cảm ơn những người này đã đẩy tôi đi đúng hướng. Tôi muốn giúp đỡ người khác vì câu trả lời được chấp nhận không phải là một đề xuất để làm màn hình giật gân.

1. Tạo ra một 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 sẽ như thế này

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

Theo mặc định, Splash Screnn không tự động làm cho Ứng dụng của bạn trông chuyên nghiệp hơn. Màn hình Splash được thiết kế chuyên nghiệp có khả năng làm cho Ứng dụng của bạn trông chuyên nghiệp hơn, nhưng nếu bạn không biết cách viết thì ứng dụng sẽ thực sự chuyên nghiệp như thế nào.

Về lý do duy nhất (lý do) để có Màn hình Splash là vì bạn đang thực hiện một số lượng Tính toán khổng lồ hoặc đang chờ GPS / WiFi khởi động vì Ứng dụng của bạn dựa vào đó trước khi bắt đầu. Nếu không có kết quả của các Tính toán hoặc truy cập vào GPS / WiFi (v.v.), Ứng dụng của bạn đã chết trong nước, do đó bạn cảm thấy cần một Màn hình Splash và PHẢI chặn chế độ xem Màn hình cho mọi Chương trình đang chạy khác (bao gồm cả Nền ).

Một màn hình Splash như vậy phải trông giống như Ứng dụng toàn màn hình của bạn để tạo ấn tượng rằng nó đã được khởi tạo, sau đó sau khi hoàn thành các tính toán dài, các chi tiết cuối cùng có thể được điền vào (Ảnh được điều chỉnh). Cơ hội của trường hợp đó hoặc đó là cách duy nhất mà Chương trình có thể được thiết kế là rất nhỏ .

Sẽ tốt hơn nếu cho phép Người dùng (và phần còn lại của HĐH) làm việc khác trong khi họ chờ thay vì thiết kế Chương trình của bạn phụ thuộc vào thứ gì đó sẽ mất một thời gian (khi thời gian chờ không chắc chắn).

Đã có Biểu tượng trên Điện thoại của bạn nói rằng GPS / WiFi đang bắt đầu. Thời gian hoặc không gian được chiếm bởi Màn hình Splash có thể được dành để tải các tính toán trước hoặc thực sự thực hiện các Tính toán. Xem Liên kết đầu tiên bên dưới để biết các vấn đề bạn tạo và những gì phải được xem xét.

Nếu bạn nhất định phải chờ các Tính toán hoặc GPS / WiFi này, tốt nhất là chỉ cần để Ứng dụng khởi động và có một cửa sổ bật lên nói rằng cần phải đợi Tính toán (Thông báo "Khởi tạo" VĂN BẢN là ổn). Chờ đợi GPS / WiFi được mong đợi (nếu chúng chưa được bật trong Chương trình khác) nên việc thông báo thời gian chờ của chúng là không cần thiết.

Hãy nhớ rằng khi Màn hình Splash khởi động Chương trình IS của bạn thực sự đã chạy, tất cả những gì bạn đang làm là trì hoãn việc sử dụng Chương trình của bạn và khiến CPU / GPU phải làm điều gì đó mà hầu hết không cảm thấy cần thiết.

Chúng tôi thực sự muốn chờ đợi để xem Màn hình Splash của bạn mỗi khi chúng tôi bắt đầu Chương trình của bạn hoặc CHÚNG TÔI sẽ không cảm thấy nó được viết rất chuyên nghiệp. Tạo màn hình Splash màn hình đầy đủ và một bản sao của màn hình chương trình thực tế (vì vậy chúng tôi nghĩ rằng nó được khởi tạo khi thực tế nó không) MIGHT hoàn thành mục tiêu của bạn (làm cho Chương trình của bạn trông chuyên nghiệp hơn) nhưng tôi sẽ không đặt cược nhiều vào điều đó.

Tại sao không làm điều đó: http://cyrilmottier.com/2012/05/03/Station-screen-are-evil-dont-use-them/

Cách thực hiện: https://encrypted.google.com/search?q=Android+Station+screen+source

Vì vậy, có một lý do chính đáng để không làm điều đó nhưng NẾU bạn chắc chắn rằng bằng cách nào đó tình huống của bạn nằm ngoài những ví dụ đó thì phương tiện để làm điều đó được đưa ra ở trên. Hãy chắc chắn rằng nó thực sự làm cho Ứng dụng của bạn trông chuyên nghiệp hơn hoặc bạn đã đánh bại lý do duy nhất bạn đưa ra để làm điều này.

Nó giống như một Kênh YouTube bắt đầu mọi Video bằng một Giới thiệu đồ họa dài (và Outro) hoặc cảm thấy cần phải nói với Joke hoặc giải thích những gì đã xảy ra trong tuần qua (khi đó không phải là Kênh Hài kịch hoặc LifeStyles). Chỉ cần hiển thị chương trình! (Chỉ cần chạy Chương trình).

Trên tất cả các câu trả lời thực sự rất tốt. Nhưng có vấn đề gặp phải rò rỉ bộ nhớ. Vấn đề này thường được biết đến trong cộng đồng Android là "Rò rỉ một hoạt động" . Bây giờ chính xác điều đó có nghĩa là gì?

Khi thay đổi cấu hình xảy ra, chẳng hạn như thay đổi hướng, Android sẽ phá hủy Hoạt động và tạo lại nó. Thông thường, Trình thu gom rác sẽ chỉ xóa bộ nhớ được phân bổ của phiên bản Hoạt động cũ và tất cả chúng ta đều tốt.

"Rò rỉ một hoạt động" đề cập đến tình huống trong đó Trình thu gom rác không thể xóa bộ nhớ được phân bổ của phiên bản Hoạt động cũ do nó xuất hiện being (strong) referencedtừ một đối tượng tồn tại đối tượng Hoạt động. Mỗi ứng dụng Android có một lượng bộ nhớ cụ thể được phân bổ cho nó. Khi Garbage Collector không thể giải phóng bộ nhớ không sử dụng, hiệu suất của ứng dụng sẽ giảm dần và cuối cùng bị OutOfMemorylỗi.

Làm thế nào để xác định xem ứng dụng có bị rò rỉ bộ nhớ hay không? Cách nhanh nhất là mở tab Bộ nhớ trong Android Studio và chú ý đến bộ nhớ được phân bổ khi bạn thay đổi hướng. Nếu bộ nhớ được phân bổ tiếp tục tăng và không bao giờ giảm thì bạn bị rò rỉ bộ nhớ.

1.Memory rò rỉ khi người dùng thay đổi hướng.

Trước tiên, bạn cần xác định màn hình giật gân trong splashscreen.xmltệp tài nguyên bố cục của bạn

Mã mẫu cho hoạt động màn hình giật gân.

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

Để biết thêm thông tin xin vui lòng đi qua liên kết này

Việc dừng trên màn hình Splash trong 5 giây không cần thiết sẽ không có ý nghĩa nhiều. Sẽ ổn nếu bạn tải một cái gì đó trong nền khác theo cách tiếp cận này để thực hiện màn hình giật gân: - Thực hiện màn hình giật gân đúng cách sẽ khác một chút so với bạn tưởng tượng. Chế độ xem giật gân mà bạn thấy phải sẵn sàng ngay lập tức, ngay cả trước khi bạn có thể thổi phồng tệp bố cục trong hoạt động giật gân của mình.

Vì vậy, bạn sẽ không sử dụng một tập tin bố trí. Thay vào đó, chỉ định nền màn hình giật gân của bạn làm nền chủ đề của hoạt động. Để làm điều này, trước tiên, hãy tạo một XML có thể vẽ được trong res / drawable.

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

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

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

</layer-list>

Ở đây, tôi đã thiết lập màu nền và hình ảnh.

Tiếp theo, bạn sẽ đặt mục này làm nền hoạt động giật gân của mình trong chủ đề. Điều hướng đến tệp Styles.xml của bạn và thêm một chủ đề mới cho hoạt động giật gân của bạn:

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

Trong SplashTheme mới của bạn, hãy đặt thuộc tính nền cửa sổ thành khả năng vẽ XML của bạn. Định cấu hình đây làm chủ đề cho hoạt động giật gân của bạn trong 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>

Cuối cùng, lớp SplashActivity sẽ chuyển tiếp bạn đến hoạt động chính của bạn:

     public class SplashActivity extends AppCompatActivity {

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

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

Xem chi tiết đọc: 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

Đây là mã đầy đủ ở đây

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

Trong drawables, hãy tạo bg_Station.xml này

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

Trong tệp XML tạo một chủ đề tùy chỉnh

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

và cuối cùng trong AndroidManifest.xml chỉ định chủ đề cho hoạt động của bạn

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

Chúc mừng.

Màn hình Splash không nên được tải từ một tệp bố cục, vẫn có thể có một số độ trễ khi tải nó.

Cách tốt nhất là tạo một Theme chỉ dành cho SplashScreenActivity của bạn và đặt the android:windowBackgroundthành một nguồn tài nguyên có thể vẽ được.

https://www.bignerdranch.com/blog/Station-screen-the-right-way/

Tóm lại:

Khai báo SplashScreenActivity của bạn trong tệp kê khai:

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

Trong SplashScreenActivity.java của bạn:

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

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

}

Tiếp theo tạo ressource cho cửa sổ nền của chủ đề của bạn:

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

Tập tin có thể vẽ được

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

Sau Android Marshmallow , việc sử dụng màn hình Splash hiệu quả khác mà tôi nghĩ đến là yêu cầu cần thiếtAndroid Permissions trong màn hình giật gân của ứng dụng.

có vẻ như hầu hết các ứng dụng xử lý yêu cầu cấp phép theo cách này.

• Các hộp thoại tạo ra UIX xấu và chúng phá vỡ luồng chính và khiến bạn quyết định thời gian chạy và sự thật là hầu hết người dùng thậm chí không quan tâm nếu ứng dụng của bạn muốn viết gì đó trên thẻ SD. Một số trong số họ thậm chí có thể không hiểu những gì chúng tôi đang cố gắng truyền đạt cho đến khi chúng tôi dịch nó bằng tiếng Anh.

• Yêu cầu quyền tại một thời điểm sẽ tạo ra số lượng "nếu khác" ít hơn trước mỗi thao tác và làm cho mã của bạn trông không bị lộn xộn.

Đây là một ví dụ về cách bạn có thể yêu cầu quyền trong hoạt động giật gân của mình cho thiết bị chạy HĐH Android 23+.

Nếu tất cả các quyền được cấp HOẶC đã được cấp HOẶC ứng dụng HOẶC đang chạy trên Pre Marshmallow THÌ chỉ cần đi và hiển thị nội dung chính với độ trễ nửa giây để người dùng có thể đánh giá cao nỗ lực mà chúng tôi đã bỏ ra khi đọc câu hỏi này và cố gắng hết sức.

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


}

bạn sẽ không sử dụng tập tin bố cục. Thay vào đó, chỉ định nền màn hình giật gân của bạn làm nền chủ đề của hoạt động. Để làm điều này, trước tiên hãy tạo một XML có thể vẽ được trong res / drawable.

Lưu ý: tất cả các mã dưới đây có sẵn 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>

Ở đây, tôi đã thiết lập màu nền và hình ảnh.

Tiếp theo, bạn sẽ đặt mục này làm nền hoạt động giật gân của mình trong chủ đề. Điều hướng đến tệp Styles.xml của bạn và thêm một chủ đề mới cho hoạt động giật gân của bạn:

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

Trong SplashTheme mới của bạn, hãy đặt thuộc tính nền cửa sổ thành khả năng vẽ XML của bạn. Định cấu hình đây làm chủ đề cho hoạt động giật gân của bạn trong 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>

Cuối cùng, lớp SplashActivity của bạn sẽ chuyển tiếp bạn đến hoạt động chính của bạn:

public class SplashActivity extends AppCompatActivity {

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

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

Lưu ý rằng bạn thậm chí không thiết lập chế độ xem cho SplashActivity này. Quan điểm xuất phát từ chủ đề. Khi bạn thiết lập giao diện người dùng cho hoạt động giật gân của mình trong chủ đề, nó sẽ khả dụng ngay lập tức.

Nếu bạn đã có tệp bố cục cho hoạt động giật gân của mình, tệp bố cục đó sẽ chỉ hiển thị cho người dùng sau khi ứng dụng của bạn được khởi tạo hoàn toàn, quá muộn. Bạn muốn phần giới thiệu chỉ được hiển thị trong khoảng thời gian nhỏ đó trước khi ứng dụng được khởi chạy.

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

Tạo một Hoạt động, hãy cho chúng tôi Hoạt động có tên 'A', sau đó tạo tệp xml có tên myscreen.xml, trong đó đặt hình ảnh màn hình giật gân làm nền, sau đó sử dụng đồng hồ đếm ngược để điều hướng từ Activtity này sang Activtity khác. Để biết cách sử dụng bộ đếm thời gian đếm ngược, hãy xem câu trả lời của tôi trong câu hỏi này TimerTask trong Android?

Ví dụ màn hình Splash:

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

    }

}

Màn hình Splash là một đối tượng không thể sử dụng được trong Android: nó không thể được tải càng sớm càng tốt để che giấu sự chậm trễ của hoạt động chính bắt đầu. Có hai lý do để sử dụng nó: quảng cáo và hoạt động mạng.

Việc thực hiện như hộp thoại giúp chuyển không chậm trễ từ màn hình giật gân sang giao diện người dùng chính của hoạt động.

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

    }
}

Bố trí:

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

Và bắt đầu:

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

    ...
}

Một cách tiếp cận khác đạt được bằng cách sử dụng 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>

Cách tiếp cận thực sự dễ dàng & gr8:

• Đầu tiên tạo giật gân của bạn với trang web sau:

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

  Chọn logo và slogan của bạn, chọn nền đẹp của bạn. thay đổi kích thước thành 4096x4096.

• Bây giờ tải xuống hình ảnh đó và nâng cấp nó lên:

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

  Và tạo ra tất cả các màn hình giật gân cần thiết, tất cả các thiết bị, tất cả các nền tảng.

Thưởng thức!

Có đủ câu trả lời ở đây sẽ giúp thực hiện. bài đăng này là để giúp đỡ người khác với bước đầu tiên tạo màn hình giật gân!

Làm thế nào về một màn hình khởi chạy siêu linh hoạt có thể sử dụng cùng một mã và được xác định trong AndroidManifest.xml, vì vậy mã sẽ không bao giờ cần phải thay đổi. Tôi thường phát triển các thư viện mã và không thích tùy chỉnh mã vì nó cẩu thả.

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

Sau đó, SpashActivity tự tìm kiếm siêu dữ liệu cho "launch_group" để sau đó tự tạo Intent. "Thời lượng" dữ liệu meta xác định thời gian màn hình giật gân duy trì.

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

Đôi khi người sử dụng mở SplashActivityvà bỏ ngay lập tức nhưng ứng dụng vẫn đi MainActivitysau SPLASH_SCREEN_DISPLAY_LENGTH.

Để ngăn chặn điều đó: Trong SplashActivitybạn nên kiểm tra xem SplashActivitycó hoàn thiện hay không trước khi chuyển đếnMainActivity

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

Hy vọng điều này giúp đỡ

Mặc dù có câu trả lời tốt, tôi sẽ chỉ cho Google cách được đề xuất:

1) Đầu tiên tạo Thememàn hình cho màn hình giật gân: bạn có một chủ đề được gọi splashscreenTheme, chủ đề trình khởi chạy của bạn sẽ là:

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

Ghi chú:

android:windowBackgroundđã thiết lập hình ảnh màn hình giật gân của bạn không
cần phải làm điều này trong UI nữa.

bạn cũng có thể sử dụng màu ở đây thay vì có thể vẽ được.

2) Đặt chủ đề thành bảng kê khai của 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) đảm bảo rằng launch_screen drawablekhông có trong drawablethư mục nếu hình ảnh của bạn không nhỏ.

Nó sẽ dẫn đến khởi động màn hình khởi động nhanh hơn và cứu bạn khỏi màn hình đen

Nó cũng tránh tình trạng quá tải

Đây là bài đăng tốt nhất tôi từng thấy trên màn hình giật gân: http://saulmm.github.io/avoding-android-cold-starts

Saúl Molinero có hai tùy chọn khác nhau cho màn hình giật gân: Tận dụng nền của cửa sổ để tạo hiệu ứng cho màn hình ban đầu của bạn và hiển thị giao diện người giữ chỗ (đây là một lựa chọn phổ biến mà Google sử dụng cho hầu hết các ứng dụng của họ hiện nay).

Tôi đề cập đến bài đăng này mỗi khi tôi cần xem xét thời gian bắt đầu lạnh và tránh người dùng bỏ học do thời gian khởi động dài.

Hi vọng điêu nay co ich!

Trong trường hợp của tôi, tôi không muốn tạo một Hoạt động mới chỉ để hiển thị một hình ảnh trong 2 giây. Khi bắt đầu MainAvtivity, hình ảnh của tôi được tải vào chủ sở hữu bằng picasso, tôi biết rằng việc này mất khoảng 1 giây để tải nên tôi quyết định thực hiện các thao tác sau trong MainActivity của mình 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);

Khi khởi động ứng dụng, điều đầu tiên xảy ra là ImageViewhiển thị và statusBar được xóa bằng cách đặt cờ cửa sổ thành toàn màn hình. Sau đó, tôi sử dụng a Handlerđể chạy trong 2 giây, sau 2 giây tôi xóa cờ toàn màn hình và đặt mức độ hiển thị của ImageViewthành GONE. Dễ dàng, đơn giản, hiệu quả.

Nó thực sự đơn giản trong Android, chúng tôi chỉ cần sử dụng khái niệm xử lý để thực hiện màn hình giật gân

Trong tệp java SplashScreenActivity của bạn dán mã này.

Trong tệp xml SplashScreenActivity của bạn, đặt bất kỳ hình ảnh nào bằng cách sử dụng hình ảnh.

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

Bạn có thể thêm phần này vào Phương thức onCreate của bạn

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

Và khởi tạo giá trị thời gian của bạn tính bằng mili giây như bạn muốn ...

private  static int time=5000;

để biết thêm chi tiết tải về mã đầy đủ từ liên kết này ...

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

Trong Kotlin viết mã này: -

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

Hy vọng điều này sẽ giúp bạn. Cảm ơn ........

Mã đơn giản, nó hoạt động :) giật gân đơn giản

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