Xamarin C# Activity On Screen (un)lock Event

Just wondering if there is an event In Xamarin for the activity class like OnStart, OnResume, OnPause etc. that gets fired when the user locks or unlocks their screen while the app

Solution 1:

Xamarin C# activity on screen (un)lock event

you could create a listener class to listen for android lock screen and unlock events，use broadcast to receive the state of screen.

first create a ScreenListener.cs :

publicclassScreenListener
{
    private Context mContext;
    private ScreenBroadcastReceiver mScreenReceiver;
    privatestatic ScreenStateListener mScreenStateListener;

    publicScreenListener(Context context)
    {
        mContext = context;
        mScreenReceiver = new ScreenBroadcastReceiver();
    }

    /**
     * screen BroadcastReceiver
     */privateclassScreenBroadcastReceiver : BroadcastReceiver
    {
    private String action = null;

        publicoverridevoidOnReceive(Context context, Intent intent)
        {
            action = intent.Action;
            if (Intent.ActionScreenOn == action)
            { // screen on
                mScreenStateListener.onScreenOn();
            }
            elseif (Intent.ActionScreenOff == action)
            { // screen off
                mScreenStateListener.onScreenOff();
            }
            elseif (Intent.ActionUserPresent == action)
            { // unlock
                mScreenStateListener.onUserPresent();
            }
        }
    }

/**
 * begin to listen screen state
 *
 * @param listener
 */publicvoidbegin(ScreenStateListener listener)
{
    mScreenStateListener = listener;
    registerListener();
    getScreenState();
}

/**
 * get screen state
 */privatevoidgetScreenState()
{
    PowerManager manager = (PowerManager)mContext
            .GetSystemService(Context.PowerService);
    if (manager.IsScreenOn)
    {
        if (mScreenStateListener != null)
        {
            mScreenStateListener.onScreenOn();
        }
    }
    else
    {
        if (mScreenStateListener != null)
        {
            mScreenStateListener.onScreenOff();
        }
    }
}

/**
 * stop listen screen state
 */publicvoidunregisterListener()
{
    mContext.UnregisterReceiver(mScreenReceiver);
}

/**
 * regist screen state broadcast
 */privatevoidregisterListener()
{
    IntentFilter filter = new IntentFilter();
    filter.AddAction(Intent.ActionScreenOn);
    filter.AddAction(Intent.ActionScreenOff);
    filter.AddAction(Intent.ActionUserPresent);
    mContext.RegisterReceiver(mScreenReceiver, filter);
}

publicinterfaceScreenStateListener
{// Returns screen status information to the callervoidonScreenOn();

    voidonScreenOff();

    voidonUserPresent();
}
}

then in the MainActivity.cs:

publicclassMainActivity : AppCompatActivity,ScreenStateListener
{
   ScreenListener mScreenListener;
   protectedoverridevoidOnCreate(Bundle savedInstanceState)
    {
        base.OnCreate(savedInstanceState);
        SetContentView(Resource.Layout.activity_main);
        mScreenListener = new ScreenListener(this);
    }
   protectedoverridevoidOnDestroy()
    {
        base.OnDestroy();
        mScreenListener.unregisterListener();
    }

   protectedoverridevoidOnResume()
    {
        base.OnResume();
        mScreenListener.begin(this);

    }
   publicvoidonScreenOn()
    {
        Console.WriteLine("onScreenOn");
    }

   publicvoidonScreenOff()
    {
        Console.WriteLine("onScreenOff");
    }

   publicvoidonUserPresent()
    {
        Console.WriteLine("onUserPresent");
    }


}

Solution 2:

Here's a sample of Xamarin.Android activities lifecycle.

You can override any of the lifecycle methods like this:

protectedoverridevoidOnResume() {
    base.OnResume(); 
}

Like in native Android OnPause is fired when the system is about to put the activity into the background. OnResume is called when the activity is ready to start interacting with the user.

OnPause and OnResume can be used for your (un)lock events.