Как определить неактивность пользователя в Android


101

Пользователь запускает мое приложение и входит в систему.
Выбирает тайм-аут сеанса равным 5 минутам.
Выполняет некоторые операции с приложением. (все на переднем плане)
Теперь пользователь переводит Myapp в фоновый режим и запускает другое приложение.
----> Таймер обратного отсчета запускается и выходит из системы через 5 минут
ИЛИ пользователь выключает экран.
----> Таймер обратного отсчета запускается и выходит из системы через 5 минут

Мне нужно такое же поведение, даже когда приложение находится на переднем плане, но пользователь не взаимодействует с приложением в течение длительного времени, скажем, 6-7 минут. Предположим, что экран включен все время. Я хочу определить тип бездействия пользователя (нет взаимодействия с приложением, даже если оно находится на переднем плане) и запустить мой таймер обратного отсчета.


1
Могли бы вы всегда включать этот таймер и сбрасывать его всякий раз, когда пользователь что-то делает?
Kyle P

Ответы:


112

Я придумал решение, которое считаю довольно простым на основе ответа Фредрика Валлениуса. Это базовый класс деятельности, который необходимо расширить на все виды деятельности.

public class MyBaseActivity extends Activity {

    public static final long DISCONNECT_TIMEOUT = 300000; // 5 min = 5 * 60 * 1000 ms


    private static Handler disconnectHandler = new Handler(new Handler.Callback() {
        @Override
        public boolean handleMessage(Message msg) {
            // todo
            return true;
        }
    });

    private static Runnable disconnectCallback = new Runnable() {
        @Override
        public void run() {
            // Perform any required operation on disconnect
        }
    };

    public void resetDisconnectTimer(){
        disconnectHandler.removeCallbacks(disconnectCallback);
        disconnectHandler.postDelayed(disconnectCallback, DISCONNECT_TIMEOUT);
    }

    public void stopDisconnectTimer(){
        disconnectHandler.removeCallbacks(disconnectCallback);
    }

    @Override
    public void onUserInteraction(){
        resetDisconnectTimer();
    }

    @Override
    public void onResume() {
        super.onResume();
        resetDisconnectTimer();
    }

    @Override
    public void onStop() {
        super.onStop();
        stopDisconnectTimer();
    }
}

3
Это создаст несколько экземпляров Handlerи Runnableдля каждого Activityсозданного. Если мы конвертируем эти два члена в static, этого можно будет избежать. Кроме того , могли бы вы сказать мне , почему вы назвали stopDisconnectTimer()в onStop()`?
Gaurav Bhor

@Gaurav В моем случае это реализовано только в одном действии (поэтому я не заметил проблемы с staticмодификатором). Что касается того onStop(), что я помню, я вызываю onBackPressed(), чтобы вернуться к экрану входа в систему в обратном вызове отключения, который, в свою очередь, вызывает onStop()метод. Когда пользователь возвращается к экрану входа в систему вручную, нажав назад, таймер также должен быть остановлен, поэтому файл stopDisconnectTimer()in onStop(). Я думаю, эта часть зависит от ваших потребностей и реализации.
gfrigon

@gfrigon можно ли перенаправить пользователя на активность входа?
Apostrofix

@Apostrifix, конечно можно. В моем случае было только одно действие: onBackPressed()достаточно было вызвать вас. Если у вас в стеке несколько действий, вам просто нужно создать намерение на этот счет. Вы можете посмотреть следующий ответ, чтобы очистить задачу Activity (и предотвратить повторное подключение пользователей на спине): stackoverflow.com/questions/7075349/…
gfrigon

Отличная работа! Я добавил геттер и сеттер для runnable, а затем установил их в расширяемом классе по мере необходимости, используя метод onCreate ... отлично, еще раз спасибо.
CrandellWS

91

Я не знаю, как отслеживать бездействие, но есть способ отслеживать активность пользователей. Вы можете поймать обратный вызов, вызываемый onUserInteraction()в ваших действиях, который вызывается каждый раз, когда пользователь взаимодействует с приложением. Я предлагаю сделать что-то вроде этого:

@Override
public void onUserInteraction(){
    MyTimerClass.getInstance().resetTimer();
}

Если ваше приложение содержит несколько действий, почему бы не поместить этот метод в абстрактный суперкласс (расширяющийся Activity), а затем все ваши действия расширять его.


1
Да, это один из способов сделать это ... но в моем приложении есть 30 различных действий, и когда пользователь активен, взаимодействие с ним будет слишком много ... так что каждый раз сброс таймера будет дорогостоящей операцией ... в худшем случае - от 50 до 60 раз в минуту.
Ах

3
Я не рассчитал время, но я бы сказал, что сбрасываю таймер, как этот lastInteraction = System.currentTimeMillis (); займет, скажем, 2 мс. Делайте это 60 раз в минуту, и вы «теряете» 120 мс. Из 60000.
Фредрик Валлениус,

1
Фредрик ... Я также использую ваше предложение, чтобы встретить этот сценарий .. Время ожидания экрана на устройстве установлено на максимум 30 минут. MyApp shd timeout через 15 минут ... Если пользователь ничего не трогает на экране более 1 минуты, я запускаю 15-минутный таймер выхода из системы .... В этом случае я бы проверил разницу (lastInteractionTime и System.currentTimeMills ( )) больше 1 мин ... потом огонь ..
Akh

3
Однако onUserInteraction () не вызывается в некоторых случаях (диалоги не вызывают его и прокручиваются в счетчиках), есть ли обходной путь для этих ситуаций?
AndroidNoob

не могли бы вы поделиться своим MyTimerClass?
Sibelius Seraphini

20

Я думаю, вам следует использовать этот код, это для 5-минутного тайм-аута сеанса ожидания: ->

Handler handler;
Runnable r;
@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    handler = new Handler();
    r = new Runnable() {

       @Override
       public void run() {
            // TODO Auto-generated method stub
            Toast.makeText(MainActivity.this, "user is inactive from last 5 minutes",Toast.LENGTH_SHORT).show();
        }
    };
    startHandler();
}
@Override
public void onUserInteraction() {
     // TODO Auto-generated method stub
     super.onUserInteraction();
     stopHandler();//stop first and then start
     startHandler();
}
public void stopHandler() {
    handler.removeCallbacks(r);
}
public void startHandler() {
    handler.postDelayed(r, 5*60*1000); //for 5 minutes 
}

Вы спасли мне жизнь с помощью onUserInteraction
codezombie

10
public class MyApplication extends Application {
      private int lastInteractionTime;
      private Boolean isScreenOff = false; 
      public void onCreate() {
        super.onCreate();
        // ......   
        startUserInactivityDetectThread(); // start the thread to detect inactivity
        new ScreenReceiver();  // creating receive SCREEN_OFF and SCREEN_ON broadcast msgs from the device.
      }

      public void startUserInactivityDetectThread() {
        new Thread(new Runnable() {
          @Override
          public void run() {
            while(true) {
              Thread.sleep(15000); // checks every 15sec for inactivity
              if(isScreenOff || getLastInteractionTime()> 120000 ||  !isInForeGrnd)
                {
                  //...... means USER has been INACTIVE over a period of
                  // and you do your stuff like log the user out 
                }
              }
          }
        }).start();
      }

      public long getLastInteractionTime() {
        return lastInteractionTime;
      }

      public void setLastInteractionTime(int lastInteractionTime) {
        this.lastInteractionTime = lastInteractionTime;
      }

      private class ScreenReceiver extends BroadcastReceiver {

        protected ScreenReceiver() {
           // register receiver that handles screen on and screen off logic
           IntentFilter filter = new IntentFilter();
           filter.addAction(Intent.ACTION_SCREEN_ON);
           filter.addAction(Intent.ACTION_SCREEN_OFF);
           registerReceiver(this, filter);
        }

        @Override
        public void onReceive(Context context, Intent intent) {
          if (intent.getAction().equals(Intent.ACTION_SCREEN_OFF)) {
            isScreenOff = true;
          } else if (intent.getAction().equals(Intent.ACTION_SCREEN_ON)) {
            isScreenOff = false;
          }
        }
      }
    }

isInForeGrnd ===> логика здесь не показана, так как она выходит за рамки вопроса

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

  if(isScreenOff || getLastInteractionTime()> 120000 ||  !isInForeGrnd)
    {
      //...... means USER has been INACTIVE over a period of
      // and you do your stuff like log the user out 

      PowerManager pm = (PowerManager) context.getSystemService(Context.POWER_SERVICE);

      boolean isScreenOn = pm.isScreenOn();
      Log.e("screen on.................................", "" + isScreenOn);

      if (isScreenOn == false) {

        PowerManager.WakeLock wl = pm.newWakeLock(PowerManager.FULL_WAKE_LOCK | PowerManager.ACQUIRE_CAUSES_WAKEUP | PowerManager.ON_AFTER_RELEASE, "MyLock");

        wl.acquire(10000);
        PowerManager.WakeLock wl_cpu = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "MyCpuLock");

        wl_cpu.acquire(10000);
      }
    }

4
@Nappy: Тогда объясните, как это правильно делать. Ваш комментарий расплывчатый и нерешительный.
Ах

2
@AKh: Другие ответы уже показывают возможности. В вашем решении я не вижу никакой пользы от опроса каждые 15 секунд. Эффект будет таким же, как если бы вы запустили таймер на «ACTION_SCREEN_OFF» со случайной длительностью от 0 до 15 секунд. Это просто не имеет смысла ..
Nappy

1
@Nappy: Каждые 15 секунд я проверяю не только SCREEN_ON или SCREEN_OFF, но также время последнего взаимодействия пользователя и статус переднего плана приложения. На основании этих трех факторов я принимаю логическое решение о том, насколько активно пользователь взаимодействует с приложением.
Akh

Пожалуйста, заполните свой комментарий. .... "if your isScreenof boolean is?" Также необходимо учитывать статус приложения.
Ах

1
Этот код полон ошибок, некоторые переменные не инициализируются.
Big.Child 05

8
@Override
public void onUserInteraction() {
    super.onUserInteraction();
    delayedIdle(IDLE_DELAY_MINUTES);
}

Handler _idleHandler = new Handler();
Runnable _idleRunnable = new Runnable() {
    @Override
    public void run() {
        //handle your IDLE state
    }
};

private void delayedIdle(int delayMinutes) {
    _idleHandler.removeCallbacks(_idleRunnable);
    _idleHandler.postDelayed(_idleRunnable, (delayMinutes * 1000 * 60));
}

Это основа решения, остальное можно модифицировать в зависимости от ваших конкретных потребностей и сложности архитектуры приложения! Спасибо за ответ!
Hack06 08

Как применить это в классе приложений
Гаджу Коллур

6

На уровне ОС, кроме широковещательных сообщений ACTION_SCREEN_OFFи, не существует концепции «бездействия пользователя» ACTION_USER_PRESENT. Вам придется как-то определить «бездействие» в вашем собственном приложении.


6

Даже вы можете управлять своими требованиями с помощью решений @gfrigon или @AKh .

Но вот бесплатное решение Timer and Handlers для этого. У меня уже есть хорошо управляемое решение с таймером для этого. Но я успешно реализовал бесплатное решение для таймера и обработчика.

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

  • Если ваше приложение убито пользователем или оптимизатором, ваше приложение никогда не выйдет из системы автоматически, потому что все ваши обратные вызовы будут уничтожены. ( Управлять каким-нибудь диспетчером сигнализации или службой? )
  • Хорошо ли иметь таймер в каждом базовом классе? Вы создаете много потоков для простого вызова процесса выхода из системы ( Управление статическим обработчиком или таймером на уровне приложения? ).
  • Что, если пользователь находится в фоновом режиме, ваш обработчик запустит активность входа, если пользователь выполняет какую-то другую работу вне вашего приложения. ( Управление передним планом или фоном приложения? ).
  • Что делать, если экран выключается автоматически. ( Управление выключением экрана на широковещательном приемнике? )

Наконец, я реализовал решение, которое

  1. НЕТ обработчика или таймера.
  2. NO Alarm Manager.
  3. НЕ управляет жизненным циклом приложения.
  4. НЕТ ACTION_SCREEN_ON/ ACTION_SCREEN_OFFрадиоприемник.

Самое простое и надежное решение

Мы не будем отслеживать бездействие пользователя по таймерам, а не будем проверять время последней активности на активность пользователя. Поэтому, когда пользователь взаимодействует с приложением в следующий раз, я проверяю время последнего взаимодействия.

Вот BaseActivity.classчто вы будете расширять из каждого вашего класса активности вместо LoginActivity. Вы определите время выхода из системы в поле TIMEOUT_IN_MILLIэтого класса.

import android.content.Intent;
import android.content.SharedPreferences;
import android.support.v7.app.AppCompatActivity;
import android.widget.Toast;

public class BaseActivity extends AppCompatActivity {
    public static final long TIMEOUT_IN_MILLI = 1000 * 20;
    public static final String PREF_FILE = "App_Pref";
    public static final String KEY_SP_LAST_INTERACTION_TIME = "KEY_SP_LAST_INTERACTION_TIME";

    @Override
    public void onUserInteraction() {
        super.onUserInteraction();
        if (isValidLogin())
            getSharedPreference().edit().putLong(KEY_SP_LAST_INTERACTION_TIME, System.currentTimeMillis()).apply();
        else logout();
    }

    public SharedPreferences getSharedPreference() {
        return getSharedPreferences(PREF_FILE, MODE_PRIVATE);
    }

    public boolean isValidLogin() {
        long last_edit_time = getSharedPreference().getLong(KEY_SP_LAST_INTERACTION_TIME, 0);
        return last_edit_time == 0 || System.currentTimeMillis() - last_edit_time < TIMEOUT_IN_MILLI;
    }

    public void logout() {
        Intent intent = new Intent(this, LoginActivity.class);
        intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK | Intent.FLAG_ACTIVITY_CLEAR_TOP);
        startActivity(intent);
        finish();
        Toast.makeText(this, "User logout due to inactivity", Toast.LENGTH_SHORT).show();
        getSharedPreference().edit().remove(KEY_SP_LAST_INTERACTION_TIME).apply(); // make shared preference null.
    }
}

1
Как доступ к общим настройкам в основном потоке при каждом взаимодействии с пользователем лучше, чем вызов нескольких потоков.
Nishita

@Nishita на момент публикации этого ответа я не знал об этом недостатке. Спасибо, что прокомментировали мой 1 плохой ответ. Вы правы, это не правильный способ. Я скрою этот ответ.
Хемрадж

2

В моем базовом классе деятельности я создал защищенный класс:

protected class IdleTimer
{
    private Boolean isTimerRunning;
    private IIdleCallback idleCallback;
    private int maxIdleTime;
    private Timer timer;

    public IdleTimer(int maxInactivityTime, IIdleCallback callback)
    {
        maxIdleTime = maxInactivityTime;
        idleCallback = callback;
    }

    /*
     * creates new timer with idleTimer params and schedules a task
     */
    public void startIdleTimer()
    {
        timer = new Timer();            
        timer.schedule(new TimerTask() {

            @Override
            public void run() {             
                idleCallback.inactivityDetected();
            }
        }, maxIdleTime);
        isTimerRunning = true;
    }

    /*
     * schedules new idle timer, call this to reset timer
     */
    public void restartIdleTimer()
    {
        stopIdleTimer();
        startIdleTimer();
    }

    /*
     * stops idle timer, canceling all scheduled tasks in it
     */
    public void stopIdleTimer()
    {
        timer.cancel();
        isTimerRunning = false;
    }

    /*
     * check current state of timer
     * @return boolean isTimerRunning
     */
    public boolean checkIsTimerRunning()
    {
        return isTimerRunning;
    }
}

protected interface IIdleCallback
{
    public void inactivityDetected();
}

Так что в методе onResume вы можете указать действие в своем обратном вызове, что вы хотите с ним делать ...

idleTimer = new IdleTimer(60000, new IIdleCallback() {
            @Override
            public void inactivityDetected() {
                ...your move...
            }
        });
        idleTimer.startIdleTimer();

как проверить, что пользователь неактивен ?? какой-либо ввод из системы?
MohsinSyd

2

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

myHandler = new Handler();
myRunnable = new Runnable() {
    @Override
    public void run() {
        //task to do if user is inactive

    }
};
@Override
public void onUserInteraction() {
    super.onUserInteraction();
    myHandler.removeCallbacks(myRunnable);
    myHandler.postDelayed(myRunnable, /*time in milliseconds for user inactivity*/);
}

например, если вы использовали 8000, задача будет выполнена через 8 секунд бездействия пользователя.


2

Бездействие пользователя можно обнаружить с помощью onUserInteraction()метода переопределения в android

  @Override
    public void onUserInteraction() {
        super.onUserInteraction();

    }

Вот пример кода, выход (HomeActivity -> LoginActivity) через 3 минуты, когда пользователь неактивен

public class HomeActivity extends AppCompatActivity {

    private static String TAG = "HomeActivity";
    private Handler handler;
    private Runnable r;


    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_home);


        handler = new Handler();
        r = new Runnable() {

            @Override
            public void run() {

                Intent intent = new Intent(getApplicationContext(), LoginActivity.class);
                startActivity(intent);
                Log.d(TAG, "Logged out after 3 minutes on inactivity.");
                finish();

                Toast.makeText(HomeActivity.this, "Logged out after 3 minutes on inactivity.", Toast.LENGTH_SHORT).show();
            }
        };

        startHandler();

    }

    public void stopHandler() {
        handler.removeCallbacks(r);
        Log.d("HandlerRun", "stopHandlerMain");
    }

    public void startHandler() {
        handler.postDelayed(r, 3 * 60 * 1000);
        Log.d("HandlerRun", "startHandlerMain");
    }

    @Override
    public void onUserInteraction() {
        super.onUserInteraction();
        stopHandler();
        startHandler();
    }

    @Override
    protected void onPause() {

        stopHandler();
        Log.d("onPause", "onPauseActivity change");
        super.onPause();

    }

    @Override
    protected void onResume() {
        super.onResume();
        startHandler();

        Log.d("onResume", "onResume_restartActivity");

    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        stopHandler();
        Log.d("onDestroy", "onDestroyActivity change");

    }

}

2

Обработка пользователя по таймауту взаимодействия в KOTLIN:

     //Declare handler
      private var timeoutHandler: Handler? = null
      private var interactionTimeoutRunnable: Runnable? = null

 override fun onCreate(savedInstanceState: Bundle?) {
      super.onCreate(savedInstanceState)
      setContentView(R.layout.activity_aspect_ratio)

       //Initialise handler
      timeoutHandler =  Handler();
      interactionTimeoutRunnable =  Runnable {
         // Handle Timeout stuffs here
          }

      //start countdown
      startHandler()
}

// reset handler on user interaction
override fun onUserInteraction() {
      super.onUserInteraction()
      resetHandler()
}

 //restart countdown
fun resetHandler() {
      timeoutHandler?.removeCallbacks(interactionTimeoutRunnable);
      timeoutHandler?.postDelayed(interactionTimeoutRunnable, 10*1000); //for 10 second

}

 // start countdown
fun startHandler() {
    timeoutHandler?.postDelayed(interactionTimeoutRunnable, 10*1000); //for 10 second
}

1

Вот полное решение, которое обрабатывает бездействие пользователя через несколько минут (например, 3 минуты). Это решает общие проблемы, такие как переход активности на передний план, когда приложение находится в фоновом режиме по истечении времени ожидания.

Во-первых, мы создаем BaseActivity, которую могут расширять все остальные Activity.

Это код BaseActivity.

package com.example.timeout;

import android.app.Activity;
import android.app.Dialog;
import android.content.Context;
import android.content.Intent;
import android.os.Bundle;
import android.text.TextUtils;
import android.view.View;
import android.view.Window;
import android.widget.TextView;

import androidx.appcompat.app.AppCompatActivity;


import javax.annotation.Nullable;

public class BaseActivity extends AppCompatActivity implements LogoutListener {

    private Boolean isUserTimedOut = false;
    private static Dialog mDialog;



    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        ((TimeOutApp) getApplication()).registerSessionListener(this);
        ((TimeOutApp) getApplication()).startUserSession();

    }

    @Override
    public void onUserInteraction() {
        super.onUserInteraction();


    }

    @Override
    protected void onResume() {
        super.onResume();

        if (isUserTimedOut) {
            //show TimerOut dialog
            showTimedOutWindow("Time Out!", this);

        } else {

            ((TimeOutApp) getApplication()).onUserInteracted();

        }

    }

    @Override
    public void onSessionLogout() {


        isUserTimedOut = true;

    }


    public void showTimedOutWindow(String message, Context context) {


        if (mDialog != null) {
            mDialog.dismiss();
        }
        mDialog = new Dialog(context);


        mDialog.requestWindowFeature(Window.FEATURE_NO_TITLE);
        mDialog.setContentView(R.layout.dialog_window);

        mDialog.setCancelable(false);
        mDialog.setCanceledOnTouchOutside(false);

        TextView mOkButton = (TextView) mDialog.findViewById(R.id.text_ok);
        TextView text_msg = (TextView) mDialog.findViewById(R.id.text_msg);

        if (message != null && (!TextUtils.isEmpty(message)) && (!message.equalsIgnoreCase("null"))) {
            text_msg.setText(message);

        }


        mOkButton.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {

                if (mDialog != null){

                    mDialog.dismiss();

                    Intent intent = new Intent(BaseActivity.this, LoginActivity.class);
                    intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK);
                    startActivity(intent);

                    finish();
                }


            }
        });

        if(!((Activity) context).isFinishing())
        {
            //show dialog
            mDialog.show();
        }

    }

}

Затем мы создаем интерфейс для нашего "Logout Listener".

package com.example.timeout;

public interface LogoutListener {

    void onSessionLogout();

}

Наконец, мы создаем класс Java, который расширяет «Приложение»

package com.example.timeout;

import android.app.Application;

import java.util.Timer;
import java.util.TimerTask;

public class TimeOutApp extends Application {

    private LogoutListener listener;
    private Timer timer;
    private static final long INACTIVE_TIMEOUT = 180000; // 3 min


    public void startUserSession () {
        cancelTimer ();

        timer = new Timer ();
        timer.schedule(new TimerTask() {
            @Override
            public void run() {

                listener.onSessionLogout ();

            }
        }, INACTIVE_TIMEOUT);

    }

    private void cancelTimer () {
        if (timer !=null) timer.cancel();
    }

    public void registerSessionListener(LogoutListener listener){
        this.listener = listener;
    }

    public void onUserInteracted () {
        startUserSession();
    }


}

Примечание. Не забудьте добавить класс TimeOutApp к тегу приложения в файле манифеста.

<application
        android:name=".TimeOutApp">
        </application>

0

Я думаю, что это нужно, комбинируя таймер с временем последней активности.

Ну вот так:

  1. В onCreate (Bundle savedInstanceState) запустите таймер, скажем, 5 минут

  2. В onUserInteraction () просто сохраните текущее время

Пока все довольно просто.

Теперь, когда таймер всплывает, сделайте следующее:

  1. Возьмите текущее время и вычтите сохраненное время взаимодействия, чтобы получить timeDelta
  2. Если timeDelta> = 5 минут, все готово.
  3. Если timeDelta <5 минут, снова запустите таймер, но на этот раз используйте 5 минут - сохраненное время. Другими словами, 5 минут до последнего взаимодействия.

0

У меня была аналогичная ситуация с вопросом SO, где мне нужно было отслеживать бездействие пользователя в течение 1 минуты, а затем перенаправлять пользователя для запуска Activity, мне также нужно было очистить стек активности.

Основываясь на ответе @gfrigon, я придумал это решение.

ActionBar.java

public abstract class ActionBar extends AppCompatActivity {

    public static final long DISCONNECT_TIMEOUT = 60000; // 1 min

    private final MyHandler mDisconnectHandler = new MyHandler(this);

    private Context mContext;


    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        mContext = this;
    }



    /*
    |--------------------------------------------------------------------------
    | Detect user inactivity in Android
    |--------------------------------------------------------------------------
    */

    // Static inner class doesn't hold an implicit reference to the outer class

    private static class MyHandler extends Handler {

        // Using a weak reference means you won't prevent garbage collection

        private final WeakReference<ActionBar> myClassWeakReference;

        public MyHandler(ActionBar actionBarInstance) {

            myClassWeakReference = new WeakReference<ActionBar>(actionBarInstance);
        }

        @Override
        public void handleMessage(Message msg) {

            ActionBar actionBar = myClassWeakReference.get();

            if (actionBar != null) {
                // ...do work here...
            }
        }
    }


    private Runnable disconnectCallback = new Runnable() {

        @Override
        public void run() {

            // Perform any required operation on disconnect

            Intent startActivity = new Intent(mContext, StartActivity.class);

            // Clear activity stack

            startActivity.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK);

            startActivity(startActivity);
        }
    };

    public void resetDisconnectTimer() {

        mDisconnectHandler.removeCallbacks(disconnectCallback);
        mDisconnectHandler.postDelayed(disconnectCallback, DISCONNECT_TIMEOUT);
    }

    public void stopDisconnectTimer() {

        mDisconnectHandler.removeCallbacks(disconnectCallback);
    }

    @Override
    public void onUserInteraction(){

        resetDisconnectTimer();
    }

    @Override
    public void onResume() {

        super.onResume();
        resetDisconnectTimer();
    }

    @Override
    public void onStop() {

        super.onStop();
        stopDisconnectTimer();
    }
}

Дополнительные ресурсы

Android: очистить стек активности

Этот класс Handler должен быть статическим, иначе могут возникнуть утечки.


0

Лучше всего справиться с этим во всем приложении (при условии, что у вас несколько действий), зарегистрировавшись AppLifecycleCallbacksв приложении calss. Вы можете использовать registerActivityLifecycleCallbacks()в классе Application со следующими обратными вызовами (я рекомендую создать класс AppLifecycleCallbacks, который расширяет ActivityLifecycleCallbacks):

public interface ActivityLifecycleCallbacks {
    void onActivityCreated(Activity activity, Bundle savedInstanceState);
    void onActivityStarted(Activity activity);
    void onActivityResumed(Activity activity);
    void onActivityPaused(Activity activity);
    void onActivityStopped(Activity activity);
    void onActivitySaveInstanceState(Activity activity, Bundle outState);
    void onActivityDestroyed(Activity activity);
}

0
open class SubActivity : AppCompatActivity() {
    var myRunnable:Runnable
    private var myHandler = Handler()

    init {
        myRunnable = Runnable{
            toast("time out")
            var intent = Intent(this, MainActivity::class.java)
            startActivity(intent)

        }
    }

    fun toast(text: String) {
        runOnUiThread {
            val toast = Toast.makeText(applicationContext, text, Toast.LENGTH_SHORT)
            toast.show()
        }
    }

   override fun onUserInteraction() {
        super.onUserInteraction();
        myHandler.removeCallbacks(myRunnable)
        myHandler.postDelayed(myRunnable, 3000)
    }

    override fun onPause() {
        super.onPause()
        myHandler.removeCallbacks(myRunnable)
    }

    override fun onResume() {
            super.onResume()
            myHandler.postDelayed(myRunnable, 3000)
    }
}

Расширьте свою деятельность с помощью

YourActivity:SubActivity(){}

чтобы перейти к MainActivity, когда пользователь неактивен после 3000 миллисекунд на YourActivity

Я использовал предыдущий ответ и преобразовал его в котлин.

Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.