Xamarin.Android
Жизненный цикл приложения - Xamarin.Andorid

Вступление

замечания

Жизненный цикл приложения

Прежде всего, вы должны знать, что вы можете расширить класс Android.Application, чтобы вы могли получить доступ к двум важным методам, связанным с жизненным циклом приложения:

• OnCreate - вызывается, когда приложение запускается, до создания каких-либо других объектов приложения (например, MainActivity).

• OnTerminate - этот метод предназначен для использования в эмулируемых средах процесса. Он никогда не будет вызываться на производственном устройстве Android, где процессы удаляются, просто убивая их; При этом не выполняется код пользователя (включая этот обратный вызов). Из документации: https://developer.android.com/reference/android/app/Application.html#onTerminate ()

В приложении Xamarin.Android вы можете расширить класс Application так, как показано ниже. Добавьте в проект новый класс под названием «MyApplication.cs»:

[Application]
public class MyApplication : Application
{
    public MyApplication(IntPtr handle, JniHandleOwnership ownerShip) : base(handle, ownerShip)
    {
    }

    public override void OnCreate()
    {
        base.OnCreate();
    }

    public override void OnTerminate()
    {
        base.OnTerminate();
    }
}

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

Существует также множество методов, которые можно переопределить, например: OnConfigurationChanged или OnLowMemory.

Жизненный цикл деятельности

Жизненный цикл деятельности довольно сложный. Как вы знаете, активность - это одна страница в приложении для Android, где пользователь может взаимодействовать с ней.

На приведенной ниже диаграмме вы можете увидеть, как выглядит жизненный цикл Android Activity:

Как вы видите, существует определенный поток жизненного цикла Activity. В мобильном приложении у вас есть, конечно, методы в каждом классе Activity, которые обрабатывают определенный фрагмент жизненного цикла:

[Activity(Label = "LifecycleApp", MainLauncher = true, Icon = "@mipmap/icon")]
public class MainActivity : Activity
{
    protected override void OnCreate(Bundle savedInstanceState)
    {
        base.OnCreate(savedInstanceState);
        Log.Debug("OnCreate", "OnCreate called, Activity components are being created");

        // Set our view from the "main" layout resource
        SetContentView(Resource.Layout.MainActivity);
    }

    protected override void OnStart()
    {
        Log.Debug("OnStart", "OnStart called, App is Active");
        base.OnStart();
    }

    protected override void OnResume()
    {
        Log.Debug("OnResume", "OnResume called, app is ready to interact with the user");
        base.OnResume();
    }

    protected override void OnPause()
    {
        Log.Debug("OnPause", "OnPause called, App is moving to background");
        base.OnPause();
    }

    protected override void OnStop()
    {
        Log.Debug("OnStop", "OnStop called, App is in the background");
        base.OnStop();
    }

    protected override void OnDestroy()
    {
        base.OnDestroy();
        Log.Debug("OnDestroy", "OnDestroy called, App is Terminating");
    }
}

В официальной документации на Android есть хорошее описание:

• Весь жизненный цикл активности происходит между первым вызовом onCreate (Bundle) до одного окончательного вызова onDestroy (). Активность будет выполнять настройку «глобального» состояния в onCreate () и освободить все оставшиеся ресурсы в onDestroy (). Например, если у него есть поток, выполняющийся в фоновом режиме для загрузки данных из сети, он может создать этот поток в onCreate (), а затем остановить поток в onDestroy ().

• Видимое время жизни активности происходит между вызовом onStart () до соответствующего вызова onStop (). В течение этого времени пользователь может видеть активность на экране, хотя он не может быть на переднем плане и взаимодействовать с пользователем. Между этими двумя методами вы можете поддерживать ресурсы, необходимые для отображения активности пользователю. Например, вы можете зарегистрировать BroadcastReceiver в onStart (), чтобы отслеживать изменения, влияющие на ваш пользовательский интерфейс, и отменить регистрацию в onStop (), когда пользователь больше не видит, что вы показываете. Методы onStart () и onStop () можно вызывать несколько раз, так как активность становится видимой и скрытой для пользователя.

• Передний жизненный цикл активности происходит между вызовом onResume () до соответствующего вызова onPause (). За это время активность перед всеми другими действиями и взаимодействием с пользователем. Активность может часто проходить между возобновленными и приостановленными состояниями - например, когда устройство переходит в спящий режим, когда доставляется результат деятельности, когда доставляется новое намерение, поэтому код в этих методах должен быть достаточно легким.

Жизненный цикл фрагментов

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

На приведенной ниже диаграмме вы можете увидеть, как выглядит жизненный цикл фрагмента Android:

Как описано в официальной документации на Android, вы должны реализовать как минимум три метода:

• OnCreate - система вызывает это при создании фрагмента. В рамках вашей реализации вы должны инициализировать основные компоненты фрагмента, которые вы хотите сохранить, когда фрагмент приостановлен или остановлен, а затем возобновлен.

• OnCreateView - система вызывает это, когда пришло время, чтобы фрагмент впервые ввел свой пользовательский интерфейс. Чтобы нарисовать пользовательский интерфейс для вашего фрагмента, вы должны вернуть представление из этого метода, который является корнем макета вашего фрагмента. Вы можете вернуть значение null, если фрагмент не предоставляет пользовательский интерфейс.

• OnPause - система вызывает этот метод как первое указание на то, что пользователь покидает фрагмент (хотя это не всегда означает уничтожение фрагмента). Обычно вы должны фиксировать любые изменения, которые должны сохраняться за пределами текущего сеанса пользователя (поскольку пользователь может не вернуться).

Вот пример реализации в Xamarin.Android:

public class MainFragment : Fragment
{
    public override void OnCreate(Bundle savedInstanceState)
    {
        base.OnCreate(savedInstanceState);

        // Create your fragment here
        // You should initialize essential components of the fragment
        // that you want to retain when the fragment is paused or stopped, then resumed.
    }

    public override View OnCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState)
    {
        // Use this to return your custom view for this Fragment
        // The system calls this when it's time for the fragment to draw its user interface for the first time.

        var mainView = inflater.Inflate(Resource.Layout.MainFragment, container, false);
        return mainView;
    }

    public override void OnPause()
    {
        // The system calls this method as the first indication that the user is leaving the fragment 

        base.OnPause();
    }
}

Конечно, здесь вы можете добавить дополнительные методы, если хотите обрабатывать разные состояния.

Полный образец GitHub

Если вы хотите получить базовый проект со способами, описанными ниже, вы можете скачать шаблон приложения Xamarin.Android из моего GitHub. Вы можете найти примеры для:

• Методы жизненного цикла приложения
• Методы жизненного цикла
• Методы жизненного цикла фрагментов

https://github.com/Daniel-Krzyczkowski/XamarinAndroid/tree/master/AndroidLifecycle/LifecycleApp