Flutter - Tutorial 002. Creating a Splash Screen with the rounting to Home Screen

Dart, Flutter

After Hello World on Flutter write an application with two screens:

• SplashScreen - Application Input Screen
• HomeScreen - Home screen application

Interestingly, Flutter has a navigation system for the windows (pages) of the application. This is somewhat similar to the route system in Django to determine which View to call.

In fact, in this application, we will need to call the MaterialApp widget, which accepts the routes route system, which will determine which windows to open. The first window will be SplashScreen , after two seconds it will have to open HomeScreen .

Project structure

I show only the necessary part of the project structure:

• main.dart - file with the main function and the launch of MaterialApp
• splash_screen.dart - initial application window
• home_screen.dart - Home application window

main.dart

import 'package:flutter/material.dart';
import 'package:evileg/screens/Splash/splash_screen.dart';
import 'package:evileg/screens/Home/home_screen.dart';
 
// Application launch
void main() => runApp(MyApp());
 
// The main application widget
class MyApp extends StatelessWidget {
 
  // We form application routing
  final routes = <String, WidgetBuilder>{
    // The path that creates the Home Screen
    '/Home': (BuildContext context) => HomeScreen(title: 'EVILEG')
  };
 
  // Redefine widget instance construction method
  @override
  Widget build(BuildContext context) {
    // This will be an application with the support of Material Design.
    return MaterialApp(
      title: 'EVILEG',
      // in which there will be a Splash Screen indicating the next route
      home: SplashScreen(nextRoute: '/Home'),
      // passing routes to the application
      routes: routes,
    );
  }
}
 

splash_screen.dart

import 'dart:core';
import 'dart:async';
import 'package:flutter/material.dart';
 
// Inheriting from the state widget
// that is, a widget for changing the state of which is not required to recreate its instance
class SplashScreen extends StatefulWidget {
  // variable to store the route
  final String nextRoute;
 
  // the constructor, the constructor body is moved to the argument area,
  // that is, immediately the arguments are passed to the body of the constructor and set by internal variables
  // Dart allows it
  SplashScreen({this.nextRoute});
 
  // all same widgets should create their own state,
  // need to override this method
  @override
  State<StatefulWidget> createState() => _SplashScreenState();
}
 
// Create a widget state
class _SplashScreenState extends State<SplashScreen> {
 
  // State initialization
  @override
  void initState() {
    super.initState();
    // Create a timer to switch SplashScreen to HomeScreen after 2 seconds.
    Timer(
      Duration(seconds: 2),
      // To do this, use the static method of the navigator.
      // This is very similar to passing the lambda function to the std::function argument in C++.
      () { Navigator.of(context).pushReplacementNamed(widget.nextRoute); }
    );
  }
 
  // Widget creation
  @override
  Widget build(BuildContext context) {
    // And this is the layout of the widget,
    // a bit like QML although obviously not a JSON structure
    return Scaffold(
      backgroundColor: Colors.blue,
      body: Center(
        child: Column(
          mainAxisAlignment: MainAxisAlignment.center,
          children: <Widget>[
            Text('EVILEG'),
            Text("Welcome to social network of programmers")
          ],
        ),
      ),
    );
  }
 
}

home_screen.dart

import 'dart:core';
import 'package:flutter/material.dart';
 
// The same widget as SplashScreen, just give it another title
class HomeScreen extends StatefulWidget {
  HomeScreen({Key key, this.title}) : super(key: key);
  final String title;
 
  @override
  _HomeScreenState createState() => _HomeScreenState();
}
 
// Creation a widget state
class _HomeScreenState extends State<HomeScreen> {
 
  // Unlike SplashScreen add AppBar
  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: Text(widget.title),
      ),
      body: Center(
        child: Column(
          mainAxisAlignment: MainAxisAlignment.center,
          children: <Widget>[
            Text('Home page',),
          ],
        ),
      ),
    );
  }
}

Conclusion

As a result, we get the following two windows of the application.

SplashScreen

It is existing 2 seconds

HomeScreen

Switches to it after SplashScreen

Java vs Dart

Of course, I haven’t been engaged in the development for Android for a very long time, and even more so in Java. Surely everything has changed a lot and it is possible that for the better, but as far as I remember, Java paid less attention to creating a state, which sometimes caused some problems. Since this state was necessary to create, save, etc. Sometimes the application fell even when the screen was rotated. This caused very big problems and inconveniences.

In Dart, widgets are created with context passing when routing between windows. That is, as I understand it, the state of the application is no longer divided into different activations, but exists more monolithically. This may solve some of the problems that were in Java, but certainly can cause other problems that were not there. Find out about this in further articles. The most interesting is how it will end. In the end, at the moment I plan to try to write a mobile application for the site on Flutter / Dart.