Create temporary lock on the app

Question

In the app I’m developing there is a usage policy, and if this policy is scammed I want to suspend the use of the app for 30 mins, how can I do this?

Answer 1

You need to implement something that allows the application to know if it is blocked or not.

This information can, as the regmoraes said, be stored in Shared Preferences.

The question now is how to know that 30 minutes have passed in order to unlock it.

One solution would be to keep, not a flag(true/false), but the value in milliseconds of the date(timestamp) where the application has been blocked.
To verify that 30 minutes have passed, just subtract between the current date and the saved date.

Method to block:

private void block(){
    SharedPreferences sharedPref = getPreferences("Pref", Context.MODE_PRIVATE);
    SharedPreferences.Editor editor = sharedPref.edit();
    editor.putLong("BlockTime", new Date().getTime());
    editor.commit();
}

Method to check if it is locked:

private boolean isBlocked(){
    SharedPreferences sharedPref = getPreferences("Pref", Context.MODE_PRIVATE);
    long blockTime = sharedPref.getLong("BlockTime", 0);
    return new Date().getTime() - blockTime < 1800000; //30*60*1000
}

EDIT:

You can prevent the system from being duped by the user if the user changes the date/time of the system as follows:

In addition to guarding the timestamp also keep a flag indicating whether it is blocked or not:

private void block(){
    SharedPreferences sharedPref = getPreferences("Pref", Context.MODE_PRIVATE);
    SharedPreferences.Editor editor = sharedPref.edit();
    editor.putLong("BlockTime", new Date().getTime());
    editor.putBoolean("IsBlocked", true);
    editor.commit();
}

Declare a Broadcastreceiver that responds to the action android.intent.action.TIME_SET. It will be called when there is a system date/time change:

Timechangereceiver.java

public class TimeChangeReceiver extends BroadcastReceiver{

    @Override
    public void onReceive(Context context, Intent intent) {

        //Houve uma alteração na data/hora do sistema
        SharedPreferences sharedPref = getPreferences("Pref", Context.MODE_PRIVATE);
        boolean isBlocked = sharedPref.getBoolean("IsBlocked", false);
        if(isBlocked){
            //Grava novo timestamp
            SharedPreferences.Editor editor = sharedPref.edit();
            editor.putLong("BlockTime", new Date().getTime());
            editor.commit();
        }
    }    
}

Register the receiver in the Androidmanifest.xml:

<receiver android:name=".TimeChangeReceiver">
    <intent-filter>
        <action android:name="android.intent.action.TIME_SET"/>
    </intent-filter>
</receiver>

Change the method isBlocked() to deal with the flag:

private boolean isBlocked(){
    SharedPreferences sharedPref = getPreferences("Pref", Context.MODE_PRIVATE);
    long blockTime = sharedPref.getLong("BlockTime", 0);
    boolean isBlocked = new Date().getTime() - blockTime < 1800000; //30*60*1000
    if(!isBlocked){
        SharedPreferences.Editor editor = sharedPref.edit();
        editor.putBoolean("IsBlocked", false);
        editor.commit();
    }
    return isBlocked
}

Call the method isBlocked() in the onResesume()

My only question is whether minor time changes due to automatic synchronizations (if connected) will or will not launch the Receiver

Answer 2

The solution that @Paulogustavo gave us in the comments is a good one, but I would make a small change:

You’d better validate the method onResume() of Activity, since that method is always called when an Activity opens, even if it has only been pause. Already the onCreate() is only called once ( when Activity is created ), therefore a "rogue" user could "circumvent" the check as follows:

1. User hurts the usage policy
2. The app hangs
3. The user leaves the app putting it in the background ( by pressing the home key, for example)
4. User opens list of recent apps and chooses your app
5. User gets back in your app normally!

This is because on this round trip, your Activity was not destroyed, it was just stopped, it means that when you open it again, the method onCreate() will not be called

Another tip I give is:

• Save a variable that indicates the app is locked in a Shared Preferences

So, when the user hurts the usage policy, you do this on your Activity:

SharedPreferences sharedPref = getActivity().getPreferences(Context.MODE_PRIVATE);
SharedPreferences.Editor editor = sharedPref.edit();
editor.putBoolean(getString(R.string.bloqueado), true);
editor.commit(); 

If you want to "unlock" the app, just write the same code above by swapping true for false.

To treat the condition of "blocked app" or not, put the following code in the method onResume() of its Activity:

SharedPreferences sharedPref = getActivity().getPreferences(Context.MODE_PRIVATE);
boolean bloqueado = sharedPref.getBoolean(getString(R.string.bloqueado), /* valor default*/ );

if(bloqueado){

    //Notifica o usuário ou fecha a Activity

}else{

   //Continue a execução da Activity normalmente
}

Answer 3

How to do the lock has already been answered, the doubt is now on how to unlock. I think do a service background would be the good solution.

As @ramaral suggested and @Fernando commented, blocking through time would be something tricky and requiring the APP to have an internet connection is also very risky seeing that it can never have after the lock and if it does, it will never have an unlock.

I believe that by creating a service we can get the result of blocking without the user being able to circumvent.

Create a service as something like this:

    public class MyService extends Service {

    private Timer timer;

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        timer = new Timer();
        timer.schedule(timerTask, 2000, 5000); //2000 representa o tempo da primeira chamada e 5000 das demais (milissegundos)
        return super.onStartCommand(intent, flags, startId);
    }

private TimerTask timerTask = new TimerTask() {
        @Override
        public void run() {

            Handler handler = new Handler(Looper.getMainLooper());
            handler.post(new Runnable() {
                @Override
                public void run() {
                    //do something

                    // stopSelf()
                }
            });

        }
    };


    }

The problem with this approach is that if the device is switched off, the service will be lost. If this happens, you will probably have to implement so that the service starts again at the device boot.