How to show loading screen class before preferences [Libgdx & android]

Question

So I am programming a game, and implemented preferences to save/load some simple data for sound/high score, nothing too much. The problem is that when I load preferences for the first time on a physical phone (samsung g. s3) it takes about 15sec and on s5 it takes about 5-8secs and in that time it shows black screen even though I have set the loading screen to be shown first, before preferences are used.

In my main application code I set screen to loadingScreen

loadingScreen = new com.package.game.Screens.LoadingScreen(this);
mainScreen = new com.package.game.Screens.MainScreen(this);
gameScreen = new com.package.game.Screens.GameScreen(this);
settingsScreen = new com.package.game.Screens.SettingsScreen(this);
this.setScreen(loadingScreen);

and then in my loading screen I access preferences:

@Override
public void show() {
    this.progress_assets = 0f;
    this.progress_assets = 0f;
    font_loading = app.initFont(50, 1, 255, 255, 255, 1);


    queueAssets();

    loading_db();
}

private void loading_db() {
    if(database.get_first_time()){
        //do some introduction for first time run
        Gdx.app.log("db","first time worked");
        database.set_first_time();
        progress_db=1f;
    }else{
        Gdx.app.log("db","first time is set false");
        progress_db=1f;
    }
}

and my preferences class:

 package com.package.game.Engine;
 import com.badlogic.gdx.Gdx;
 import com.badlogic.gdx.Preferences;
 import com.package.game.Application;

 public class Database {
private Preferences preferences;
//database
private Preferences pref_settings;
private Preferences pref_score;
private Preferences pref_unlocks;
public Database(){
        pref_settings = Gdx.app.getPreferences("com.package.game.settings");
        pref_score = Gdx.app.getPreferences("com.package.game.score");
        pref_unlocks = Gdx.app.getPreferences("com.package.game.unlocks");

}


//checking if first time run
public boolean get_first_time(){
    return pref_settings.getBoolean("First_run",true);

}
public void set_first_time(){
    pref_settings.putBoolean("First_run",false);
    for(int i=0;i<7;i++){
       pref_unlocks.putBoolean("unlock_"+i,true);
    }
    pref_unlocks.flush();
    pref_settings.flush();
}
//settings
public boolean getSound(){
        return pref_settings.getBoolean("sound_on",true);
}
public void setSound(boolean sound){
    pref_settings.putBoolean("sound_on",sound);
    pref_settings.flush();
}
//High Score Mode:
//Classic
public int getScore_classic(int place){
    return pref_score.getInteger("score_classic_"+place,0);//default value 0 so we could place new score if we havent reached it
}
public void setScore_classic(int place,int scored){
    pref_score.putInteger("score_classic_"+place,scored);
    pref_score.flush();
}
//Recipe
public int getScoreRec(int place){

    return pref_score.getInteger("score_recipe_"+place,0);//default value 0 so we could place new score if we havent reached it
}
public void setScoreRec(int place,int scored){

    pref_score.putInteger("score_recipe_"+place,scored);
    pref_score.flush();
}
//food unlocks
public boolean getFoodUnlock(int unlockID){
    return pref_unlocks.getBoolean("unlock_"+unlockID,false);
}
public void setFoodUnlock(int unlockID,boolean state){
    pref_unlocks.putBoolean("unlock_"+unlockID,state);
    pref_unlocks.flush();
}
}

I'm not sure if creating 3 pref. files is good, but i would like to know how to show screen before pref. file being created/loaded.

Edit: Adding my main code

package com.mindutis.game;

import com.badlogic.gdx.Game;
import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.Preferences;
import com.badlogic.gdx.assets.AssetManager;
import com.badlogic.gdx.graphics.Color;
import com.badlogic.gdx.graphics.GL20;
import com.badlogic.gdx.graphics.OrthographicCamera;
import com.badlogic.gdx.graphics.Texture;
import com.badlogic.gdx.graphics.g2d.BitmapFont;
import com.badlogic.gdx.graphics.g2d.SpriteBatch;
import com.badlogic.gdx.graphics.g2d.freetype.FreeTypeFontGenerator;
import com.badlogic.gdx.utils.viewport.ExtendViewport;
import com.mindutis.game.Screens.LoadingScreen;

public class Application extends Game {
public static  int V_WIDTH ;
public static  int V_HEIGHT;

public OrthographicCamera camera;
public SpriteBatch batch;

public AssetManager assets;
public com.mindutis.game.Screens.LoadingScreen loadingScreen;
public com.mindutis.game.Screens.SplashScreen splashScreen;
public com.mindutis.game.Screens.MainScreen mainScreen;
public com.mindutis.game.Screens.GameScreen gameScreen;
public com.mindutis.game.Screens.SettingsScreen settingsScreen;
public BitmapFont f_game_name;
public String t_game_name;
public String[] font_type = new String[2];
private boolean firstFrame = true;
private boolean loading = true;



@Override
public void create() {

    assets = new AssetManager();
    camera = new OrthographicCamera();
    V_WIDTH= Gdx.graphics.getWidth();
    V_HEIGHT = Gdx.graphics.getHeight();
    camera.setToOrtho(false, V_WIDTH, V_HEIGHT);
    batch = new SpriteBatch();

    //Global var.
    //font initializer
    font_type[0] = "fonts/comics_bold.ttf";
    font_type[1] = "fonts/vdj.ttf";
    //game name
    t_game_name = " Catch a\nSandwich";
    f_game_name = initFont(70, 0, 255, 255, 255, 1);


    loadingScreen = new com.mindutis.game.Screens.LoadingScreen(this);
    splashScreen = new com.mindutis.game.Screens.SplashScreen(this);
    mainScreen = new com.mindutis.game.Screens.MainScreen(this);
    gameScreen = new com.mindutis.game.Screens.GameScreen(this);
    settingsScreen = new com.mindutis.game.Screens.SettingsScreen(this);


 //   this.setScreen(loadingScreen);
}

//int size=font size, int x = font type
public BitmapFont initFont(int size, int type, float red, float green, float blue, float alpha) {
    BitmapFont font;
    FreeTypeFontGenerator generator = new FreeTypeFontGenerator(Gdx.files.internal(font_type[type]));
    FreeTypeFontGenerator.FreeTypeFontParameter parameter = new FreeTypeFontGenerator.FreeTypeFontParameter();
    parameter.size = size;
    font = generator.generateFont(parameter);
    font.setColor(red / 255f, green / 255f, blue / 255f, alpha);
    return font;
}

@Override
public void render() {
    if (firstFrame){
        Gdx.gl.glClearColor(.2f, .67f, .88f, 1);
        Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);
        batch.begin();
        f_game_name.draw(batch, t_game_name, camera.viewportWidth / 2 - 150, camera.viewportHeight - 100);
        batch.end();
        firstFrame = false;
    } else {
       if(loading){
           loading=false;
           loadEverything();
       }
        // Notice you don't actually render anything so what you previously drew stays on the screen.

       }
    super.render();

}
private void loadEverything(){
    // load your font, assets, prefs, etc.

    this.setScreen(loadingScreen);
   // setScreen(loadingScreen);
}
@Override
public void dispose() {
    batch.dispose();
    assets.dispose();
    f_game_name.dispose();
    loadingScreen.dispose();
    splashScreen.dispose();
    mainScreen.dispose();
    gameScreen.dispose();
    settingsScreen.dispose();

}

}

Loading screen class:

package com.mindutis.game.Screens;

import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.Input;
import com.badlogic.gdx.InputAdapter;
import com.badlogic.gdx.Screen;
import com.badlogic.gdx.graphics.Color;
import com.badlogic.gdx.graphics.GL20;
import com.badlogic.gdx.graphics.Texture;
import com.badlogic.gdx.graphics.g2d.BitmapFont;
import com.badlogic.gdx.graphics.glutils.ShapeRenderer;
import com.badlogic.gdx.math.MathUtils;
import com.badlogic.gdx.scenes.scene2d.Stage;
import com.badlogic.gdx.utils.viewport.FitViewport;
import com.mindutis.game.Application;
import com.mindutis.game.Engine.Database;

public class LoadingScreen implements Screen {

private final Application app;
private Database database;
private BitmapFont font_loading;
private boolean load;
private ShapeRenderer shapeRenderer;
private Stage stage;

private String t_loading;
private float progress_assets,progress_db;


private boolean firstFrame = true;
private boolean loading = true;

public LoadingScreen(Application app) {
    this.app = app;
    database = new Database();
    this.stage = new Stage(new FitViewport(com.mindutis.game.Application.V_WIDTH, com.mindutis.game.Application.V_HEIGHT, app.camera));
    this.shapeRenderer = new ShapeRenderer();
    t_loading = "Loading...";
load=false;

}

private void queueAssets() {
    //good food
    //bread
    app.assets.load("img/Food/breadtop.png", Texture.class);

    app.assets.load("img/Food/breadbot.png", Texture.class);
    //rest of the food
    app.assets.load("img/Food/food_sheet.png", Texture.class);
      //misc
    app.assets.load("img/Misc/coin.png", Texture.class);
   app.assets.load("img/Misc/soon.png", Texture.class);
       app.assets.load("img/Misc/shoptriangle.png", Texture.class);
     //buttons
    app.assets.load("img/Buttons/button.png", Texture.class);
     app.assets.load("img/Buttons/soundBT.png", Texture.class);
     app.assets.load("img/Buttons/btX.png", Texture.class);
      app.assets.load("img/Buttons/btShop1.png", Texture.class);
    //human
    app.assets.load("img/Human/human.png", Texture.class);
     app.assets.load("img/Human/human1.png", Texture.class);
       app.assets.load("img/Human/human2.png", Texture.class);


}

@Override
public void show() {
    this.progress_assets = 0f;
    this.progress_assets = 0f;
    font_loading = app.initFont(50, 1, 255, 255, 255, 1);


    queueAssets();

    loading_db();
}

private void loading_db() {
    if(database.get_first_time()){
        //do some introduction for first time run
        Gdx.app.log("db","first time worked");
        database.set_first_time();
        progress_db=1f;
    }else{
        Gdx.app.log("db","first time is set false");
        progress_db=1f;
    }
}

@Override
public void render(float delta) {
    if (firstFrame){
        Gdx.gl.glClearColor(.2f, .67f, .88f, 1);
        Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);
        app.batch.begin();
        app.f_game_name.draw(app.batch, app.t_game_name, app.camera.viewportWidth / 2 - 150, app.camera.viewportHeight - 100);
        app.batch.end();
        firstFrame = false;
    } else {
        if(loading){
            loading=false;}
             //input
            Gdx.input.setCatchBackKey(true);
            Gdx.input.setInputProcessor(new InputAdapter() {
                @Override
                public boolean keyDown(int keycode) {
                    if (keycode == Input.Keys.BACK) {
                        // Do nothing
                    }
                    return false;
                }
            });
            Gdx.gl.glClearColor(.2f, .67f, .88f, 1);
            Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);

            update(delta);

            app.batch.begin();
            font_loading.draw(app.batch, t_loading, app.camera.viewportWidth / 2 - 150, 123);
            app.f_game_name.draw(app.batch, app.t_game_name, app.camera.viewportWidth / 2 - 150, app.camera.viewportHeight - 100);
            app.batch.end();

            shapeRenderer.begin(ShapeRenderer.ShapeType.Filled);
            shapeRenderer.setColor(Color.WHITE);
            shapeRenderer.rect(32, 50, app.camera.viewportWidth - 64, 16);

            shapeRenderer.setColor(Color.GREEN);
            shapeRenderer.rect(32, 50, (progress_assets+progress_db)/2 * (app.camera.viewportWidth - 64), 16);
            shapeRenderer.end();

        }
        // Notice you don't actually render anything so what you previously drew stays on the screen.

    }






private void update(float delta) {
    progress_assets = MathUtils.lerp(progress_assets, app.assets.getProgress(), .1f);
    if (app.assets.update() && (progress_assets+progress_db)/2 >= app.assets.getProgress() - .01f) {

        app.setScreen(app.mainScreen);
    }
}

@Override
public void resize(int width, int height) {
    stage.getViewport().update(width, height, false);
}

@Override
public void pause() {

}

@Override
public void resume() {

}

@Override
public void hide() {

}

@Override
public void dispose() {

    shapeRenderer.dispose();
    font_loading.dispose();
    stage.dispose();

}
}

Answer 1

You can quickly load a single texture to show while everything else loads. Load and show the texture the first time render() is called. Then the second time render() is called, load your stuff, dispose the texture, and switch screens.

public class LoadingScreen extends Screen {

    private boolean firstFrame = true;
    private Texture texture;
    private ExtendViewport viewport;
    private MyGame game;
    private SpriteBatch batch;
    private static final float LOAD_IMAGE_WIDTH = 480, LOAD_IMAGE_HEIGHT = 600;
    // Use whatever the loading image dimensions are.

    public LoadingScreen (MyGame game, SpriteBatch batch){
        this.game = game;
        this.batch = batch;
        viewport = new ExtendViewport(LOAD_IMAGE_WIDTH, LOAD_IMAGE_HEIGHT);
    }

    public void resize (int width, int height) {
        viewport.update(width, height, false);
        viewport.getCamera().position.set(LOAD_IMAGE_WIDTH / 2, LOAD_IMAGE_HEIGHT / 2, 0);
        viewport.getCamera().update();
    }

    public void show (){} // do nothing

    public void render (float delta) {

        if (firstFrame){
            Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);
            viewport.apply();
            batch.setProjectionMatrix(viewport.getCamera().combined);
            batch.setBlendingDisabled(true);
            batch.begin();
            batch.draw(texture, 0, 0, LOAD_IMAGE_WIDTH, LOAD_IMAGE_HEIGHT);
            batch.end();
            firstFrame = false;
        } else {
            loadEverything(); 
            // Notice you don't actually render anything so what you previously drew stays on the screen.
        }
    }

    private void loadEverything(){
        // load your font, assets, prefs, etc.

        texture.dispose();
        main.setGameScreen();
    }
}