Как добавить текст на экран Android Splash? [Дубликат]

вы не будете использовать файл макета. Вместо этого укажите фон вашего заставки в качестве фона темы мероприятия. Для этого сначала создайте XML-чертеж в res / drawable.

Примечание: доступен весь код ниже GitHub Link

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

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

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

</layer-list>

Здесь I Вы установили фоновый цвет и изображение.

Затем вы установите это как фоновый фон вашей всплеска в теме. Перейдите к файлу 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. Взгляд исходит из темы. Когда вы настраиваете пользовательский интерфейс для своей активности всплеска в теме, он доступен сразу.

Если у вас был файл макета для вашей активности всплеска, этот файл макета будет отображаться для пользователя только после вашего приложение полностью инициализировано, что слишком поздно. Вы хотите, чтобы всплеск отображался только за это небольшое количество времени до того, как приложение будет инициализировано.

Его очень просто в android, мы просто используем концепцию обработчика для реализации заставки

. В вашем java-файле 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);
    }

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

Это полный код здесь

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

В drawables создайте этот 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>

Приветствия.

В моем случае я не хотел создавать новую активность только для показа изображения в течение 2 секунд. При запуске моего MainAvtivity изображения загружаются в держатели с использованием picasso, я знаю, что для загрузки требуется около 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, а статусBar удаляется установкой флажков окна на полный экран. Затем я использовал Handler для запуска в течение 2 секунд, после 2 секунд я очищаю флаги полного экрана и устанавливаю видимость ImageView на GONE. Легко, просто, эффективно.

• Создайте действие: Splash
• Создайте XML-файл макета: splash.xml
• Поместите компоненты пользовательского интерфейса в макет 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>

Хотя есть хорошие ответы, я покажу рекомендуемый google путь:

1) Сначала создайте Theme для заставки: у вас есть тема под названием splashscreenTheme, ваша тема запуска будет :

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

Примечание:

android:windowBackground уже устанавливает, что ваше изображение с заставкой не нужно делать это в интерфейсе пользователя.

вы также можете использовать цвет здесь

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) убедитесь, что вы запускаете [screen screen] drawable не в папке drawable, если ваше изображение

Это приведет к ускорению запуска экрана запуска и спасению вас от черного экрана

Он также избегает дополнительного превышения

Создайте Activity, давайте действовать с именем «A», затем создадим xml-файл с именем myscreen.xml, в котором задано изображение заставки в качестве фона, а затем используйте таймер обратного отсчета для перехода от одной Activitity к другой. Чтобы узнать, как использовать таймер Count Down, см. Мой ответ в этом вопросе TimerTask в Android?

Заставки не должны загружаться из файла макета, все равно может быть некоторое отставание при загрузке.

Лучший способ - создать тему только для вашей 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>

Drawable file 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 другое полезное использование экрана Splash, о котором я придумываю, запрашивает необходимый Android Permissions в заставке вашего приложения.

похоже, что большинство приложений обрабатывают запрос разрешения таким образом.

• Диалоги делают плохой UIX, и они ломают основной поток и заставляют вас определять время выполнения, а правда - большинство пользователей могут даже не волнует, если ваше приложение хочет что-то написать на SD-карте. Некоторые из них, возможно, даже не понимают, что мы пытаемся передать, пока мы не переведем его на простом английском языке.
• Запрос разрешений в одно время делает меньше числа «если есть» перед каждой операцией и делает ваш код искаженным

Это пример того, как вы можете запрашивать разрешения в вашей активности всплеска для устройства под управлением ОС Android 23+.

Если все разрешения предоставлены ИЛИ уже предоставлены ИЛИ приложение работает на Pre Marshmallow THEN, просто перейдите и отобразите основное содержимое с небольшой задержкой в ​​полсекунды, чтобы пользователь мог оценить усилие, которое мы поставили при чтении этого вопроса и попытке чтобы приложить все усилия.

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


}

Как насчет сверхгибкого экрана запуска, который может использовать тот же код и определен в AndroidManifest.xml, поэтому код никогда не понадобится изменять. Я вообще-то разрабатываю библиотеки кода и не люблю настраивать код, потому что он неаккуратный.

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

Затем сам SpashActivity ищет метаданные для «launch_class», чтобы затем сделать сам Intent. «Длительность» метаданных определяет, как долго экран заставки будет оставаться.

public class SplashActivity extends Activity {

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

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

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

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

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

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

Действительно легкий & amp; gr8:

• Сначала создайте свой всплеск со следующим веб-сайтом: https://www.norio.be/android-feature-graphic-generator/ Выберите свой логотип и слоган, выберите свой красивый фон. измените его на 4096x4096.
• Теперь загрузите эту картинку и уложите ее в: https://apetools.webprofusion.com/app/#/tools/imagegorilla И создайте весь всплеск экраны, все устройства, все платформы.

Наслаждайтесь!

Здесь достаточно ответов, которые помогут в реализации. этот пост должен был помочь другим с первого шага создания экрана-заставки!

Пример экрана заставки:

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 как «Утечка активности». Теперь, что именно это означает?

Когда происходит изменение конфигурации, например изменение ориентации, Android уничтожает Activity и воссоздает его. Обычно сборщик мусора просто очищает выделенную память от старого экземпляра Activity, и мы все хороши.

«Утечка активности» относится к ситуации, когда сборщик мусора не может очистить выделенную память старый экземпляр Activity, так как это being (strong) referenced из объекта, из которого жил экземпляр Activity. Каждое приложение для Android имеет определенный объем памяти, выделенный для него. Когда сборщик мусора не может освободить неиспользованную память, производительность приложения будет постепенно уменьшаться и, в конечном счете, сбой с ошибкой OutOfMemory.

Как определить, что приложение утечки памяти или нет? Самый быстрый способ - открыть вкладку «Память» в Android Studio и обратить внимание на выделенную память при изменении ориентации. Если выделенная память продолжает увеличиваться и никогда не уменьшается, тогда у вас есть утечка памяти.

1. Утечка памяти, когда пользователь меняет ориентацию.

Сначала вам нужно определить заставку в вашем ресурсе макета splashscreen.xml file

Пример кода для активности заставки.

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

Для получения дополнительной информации перейдите по этой ссылке

@ Ответ Абдуллы верен, однако Google опубликовал расширенное объяснение того, как правильно реализовать это, не изменяя тему вашей деятельности:

https://plus.google.com/+AndroidDevelopers / posts / Z1Wwainpjhd

Приложения, такие как Google Maps и YouTube, начали использовать тот же метод.

Обратите внимание, что это решение не позволит пользователю подождать больше: задержка всплывающего экрана зависит от времени запуска приложения.

Когда вы открываете любое приложение для Android, по умолчанию вы получите какой черный экран с заголовком и значком приложения сверху, вы можете изменить это, используя стиль / тему.

Сначала создайте папку 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);
}

UPDATE Проверьте этот пост https://plus.google.com/ + AndroidDevelopers / posts / Z1Wwainpjhd Благодаря @ mat1h и @adelriosantiago

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> 
   

Я использовал потоки, чтобы сделать Flash-экран в android.

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

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

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

Когда-нибудь пользователь откройте 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);
        }                             
   }                                
}

Надейтесь на эту помощь

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

Splash Screnn по умолчанию не делает ваше приложение более профессиональным. Профессионально спроектированный Splash Screen имеет возможность сделать ваше приложение более профессиональным, но если вы не знаете, как его написать, то насколько профессиональным будет остальное ваше приложение на самом деле.

О единственной причине ( извините), чтобы иметь экран заставки, потому что вы делаете огромное количество вычислений или ожидаете запуска GPS / WiFi, потому что ваше приложение полагается на то, что до его запуска. Без результатов этих вычислений или доступа к GPS / WiFi (и т. Д.) Ваше приложение мертво в воде, поэтому вы чувствуете, что вам нужен экран всплеска, и ДОЛЖЕН блокировать просмотр экрана для любых других запущенных программ (включая фоновый ).

Такой экран заставки должен выглядеть как ваше полноэкранное приложение, чтобы создать впечатление, что оно уже инициализировано, а затем после завершения длительных вычислений могут быть заполнены окончательные детали (изображение изменено) , Вероятность того, что это так, или что это единственный способ разработки Программы, очень мала.

Лучше разрешить Пользователю (и остальной ОС) делать что-то еще в то время как они ждут, а не разрабатывают вашу Программу, чтобы зависеть от чего-то, что займет некоторое время (когда продолжительность ожидания не определена).

На вашем телефоне уже есть значки, которые говорят, что GPS / WiFi запускается. Время или пространство, занимаемое экраном всплеска, можно потратить на загрузку предварительных вычислений или фактически выполнение вычислений. См. Первую ссылку ниже для проблем, которые вы создаете, и что нужно учитывать.

Если вы абсолютно должны дождаться этих вычислений или GPS / WiFi, было бы лучше всего просто запустить приложение и получить всплывающее окно, который говорит, что нужно ждать расчетов (текстовое сообщение «Инициализация» в порядке). Ожидание GPS / WiFi ожидается (если они еще не были активированы в другой программе), поэтому анонсировать их время ожидания не нужно.

Помните, что когда заставка запускает вашу программу, на самом деле запущена, все, что вы делают это, задерживая использование вашей Программы и заставляя CPU / GPU делать что-то, что больше всего не ощущается.

Нам действительно хотелось бы подождать и увидеть ваш экран Splash каждый раз, когда мы запускаем вашу программу, или мы не будем чувствовать, что это очень профессионально написано. Создание экрана всплеска FULL и дублирования фактического экрана программы (поэтому мы думаем, что он инициализируется, когда на самом деле это не так) МОЖНО выполнить свою задачу (сделать вашу программу более профессиональным), но я бы не стал делать ставку на это.

Почему бы не сделать это: http://cyrilmottier.com/2012/05/03/splash-screens-are-evil-dont-use-them/

Как это сделать: https://encrypted.google.com/search?q=Android+splash+screen+source

Итак, есть хорошая причина не делать этого, но если вы уверены, что каким-то образом ваша ситуация выходит за рамки этих примеров, то средства для этого даются выше. Будьте уверены, что это действительно делает ваше приложение более профессиональным, или вы победили единственную причину, которую вы дали для этого.

Это похоже на канал YouTube, который запускает каждое видео с длинным графическим вводом (и Outro ) или чувствует необходимость рассказать анекдот или объяснить, что произошло на прошлой неделе (когда это не комедия или канал LifeStyles). Просто покажите шоу! (Просто запустите программу).

public class MainActivity extends Activity {

@Override

public void onCreate(Bundle savedInstanceState) {

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

    Thread t=new Thread()
    {

        public void run()
        {   

            try {

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

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

Заставка - это немного непригодный для использования объект в Android: он не может быть загружен как можно скорее для скрытия задержки запуска основной активности. Для этого есть две причины: реклама и сетевые операции.

Выполнение в качестве диалога делает переход без зазора от экрана всплеска до основного пользовательского интерфейса активности.

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

Ответ Абдуллы велик. Но я хочу добавить к нему еще несколько подробностей с моим ответом.

Реализация экрана заставки

Реализация заставки экрана правильного пути немного отличается от того, что вы можете себе представить. Взгляд всплеска, который вы видите, должен быть готов немедленно, даже до того, как вы сможете раздуть файл макета в своей активности всплеска.

Таким образом, вы не будете использовать файл макета. Вместо этого укажите фон вашего заставки в качестве фона темы мероприятия. Для этого сначала создайте XML-чертеж в res / drawable.

background_splash.xml

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

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

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

</layer-list>

Это просто список слоев с логотипом в центре фона с ним.

Теперь откройте styles.xml и добавьте этот стиль

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

. Эта тема должна иметь панель действий и фон, который мы только что создали выше.

И в манифесте вам нужно для установки SplashTheme на активность, которую вы хотите использовать в качестве всплеска.

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

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

Затем внутри вашего кода активности перейдите на конкретный экран после всплеска с использованием намерения.

public class SplashActivity extends AppCompatActivity {

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

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

Это правильный способ сделать. Я использовал эти ссылки для ответа.

1. https://material.google.com/patterns/launch-screens.html
2. https://www.bignerdranch.com/blog/splash-screens-the-right-way/ Спасибо этим парням за то, что они меня толкали в правильном направлении. Я хочу помочь другим, потому что принятый ответ не рекомендуется делать заставки.

Остановка на экране Splash для 4's 5 без необходимости не имеет большого смысла. Это нормально, если вы загружаете что-то в фоновом режиме, следуйте этому подходу, чтобы реализовать заставку: - Внедрение заставки - это немного иначе, чем вы могли себе представить. Представление всплеска, которое вы видите, должно быть готово немедленно, даже до того, как вы сможете раздуть файл макета в своей активности всплеска.

Таким образом, вы не будете использовать файл макета. Вместо этого укажите фон вашего заставки в качестве фона темы мероприятия. Для этого сначала создайте XML-чертеж в 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>

Здесь я установил цвет фона и изображение.

Затем вы будете установите это как фоновый фон вашей брызги в теме. Перейдите к файлу 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- советы к Create-A-great-заставку-для-вашего-подвижной app_a287.html

Это лучший пост, который я видел на экранах заставки: http://saulmm.github.io/avoding-android-cold-starts

Saúl Molinero идет в двух разных вариантах для заставки: использование фона окна для анимации на вашем первом экране и отображение пользовательского интерфейса (который является популярным выбором, который Google использует для большинства своих приложений в наши дни).

I обратитесь к этому сообщению каждый раз, когда мне нужно рассмотреть время холодного запуска и избежать отказа пользователя из-за длительного времени запуска.

Надеюсь, что это поможет!

Ответы выше очень хорошие, но я хотел бы добавить что-то еще. Я новичок в Android, я встретил эту проблему во время своего развития. надеюсь, что это может помочь кому-то вроде меня.

1. Экран Splash - это точка входа моего приложения, поэтому добавьте следующие строки в AndroidManifest.xml.

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

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

счастливое кодирование!