كيفية اكتشاف عدم نشاط المستخدم في أندرويد

Question

يبدأ المستخدم تطبيقي ويسجل الدخول.
تحديد مهلة الجلسة لتكون 5 دقائق.
يقوم ببعض العمليات على التطبيق.(الكل في المقدمة)
الآن يقوم المستخدم بإحضار Myapp إلى الخلفية ويبدأ تشغيل بعض التطبيقات الأخرى.
----> يبدأ مؤقت العد التنازلي ويسجل خروج المستخدم بعد 5 دقائق
أو يقوم المستخدم بإيقاف تشغيل الشاشة.
----> يبدأ مؤقت العد التنازلي ويسجل خروج المستخدم بعد 5 دقائق

أريد نفس السلوك حتى عندما يكون التطبيق في المقدمة ولكن المستخدم لا يتفاعل مع التطبيق لمدة 6-7 دقائق على سبيل المثال.افترض أن الشاشة قيد التشغيل طوال الوقت.أريد الكشف عن نوع من عدم نشاط المستخدم (لا يوجد تفاعل مع التطبيق على الرغم من وجود التطبيق في المقدمة) وابدأ العد التنازلي.

Answer 1

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;
          }
        }
      }
    }

لا يتم عرض المنطق هنا لأنه خارج نطاق السؤال

يمكنك إيقاظ القفل على وحدة المعالجة المركزية باستخدام رمز الجهاز أدناه-

  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);
      }
    }

Answer 2

توصلت إلى حل أجده بسيطًا جدًا بناءً على إجابة فريدريك والينيوس. هذه فئة النشاط الأساسية التي يجب تمديدها من خلال جميع الأنشطة.

public class MyBaseActivity extends Activity {

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


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

    private 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();
    }
}

Answer 3

لا أعرف طريقة لتتبع عدم النشاط ولكن هناك طريقة لتتبع نشاط المستخدم. يمكنك التقاط رد اتصال يسمى onUserInteraction() في أنشطتك التي تسمى في كل مرة يقوم فيها المستخدم بأي تفاعل مع التطبيق. أقترح فعل شيء مثل هذا:

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

إذا كان تطبيقك يحتوي على العديد من الأنشطة ، فلماذا لا تضع هذه الطريقة في فئة سوبر مجردة (تمتد Activity) ثم اطلب من كل الأنشطة التي تمديدها.

Answer 4

أعتقد أنه يجب عليك الذهاب مع هذا الرمز ، وهذا هو لمدة 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 
}

Answer 5

@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));
}

Answer 6

لا يوجد مفهوم لـ "عدم نشاط المستخدم" على مستوى نظام التشغيل ، بعد ACTION_SCREEN_OFF و ACTION_USER_PRESENT البث. سيتعين عليك تحديد "عدم النشاط" بطريقة أو بأخرى ضمن تطبيقك الخاص.

Answer 7

حتى يمكنك إدارة متطلباتك مع gfrigon أو @آك حلول.

لكن هنا الموقت والحلول المجاني لهذا. لدي بالفعل حل توقيت مُدار جيدًا لهذا الغرض. لكنني قمت بنجاح بتطبيق التوقيت والحل المجاني.

أولا أقول لك ما عليك إدارته إذا كنت تستخدم مؤقتًا أو معالجات.

• إذا تم قتل التطبيق الخاص بك من قبل المستخدم أو بواسطة مُحسّن ، فلن يتم تسجيل تطبيقك تلقائيًا أبدًا ، لأنه يتم تدمير جميع عمليات الاسترجاع الخاصة بك. ((إدارة بعض مدير الإنذار أو الخدمة؟)
• هل من الجيد أن يكون لديك مؤقت في كل فصل أساسي؟ أنت تقوم بعمل العديد من المواضيع لاستدعاء عملية تسجيل الدخول (إدارة المعالج الثابت أو المؤقت على مستوى التطبيق؟).
• ماذا لو كان المستخدم في الخلفية ، سيبدأ معالجك نشاط تسجيل الدخول إذا كان المستخدم يقوم ببعض الأعمال الأخرى خارج تطبيقك. ((إدارة التطبيق الأمامي أو الخلفية؟).
• ماذا لو تم إيقاف الشاشة تلقائيًا. ((إدارة الشاشة على جهاز استقبال البث؟)

أخيرًا ، قمت بتطبيق حل

1. لا معالج أو مؤقت.
2. لا يوجد مدير إنذار.
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.
    }
}

Answer 8

في فئة قاعدة النشاط ، قمت بإنشاء فئة محمية:

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();

Answer 9

أثناء بحثي ، وجدت الكثير من الإجابات ، لكن هذا هو أفضل إجابة حصلت عليها. لكن الحد من هذا الرمز هو أنه يعمل فقط للنشاط وليس للتطبيق بأكمله. خذ هذا كمرجع.

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 ثوان من عدم نشاط المستخدم.

Answer 10

يمكن أن يكتشف عدم نشاط المستخدم باستخدام onUserInteraction() طريقة التجاوز في Android

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

    }

هنا هو نموذج التعليمات البرمجية، تسجيل (HomeActivity-> تسجيل الدخول) بعد 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");

    }

}

Answer 11

أعتقد أنه يجب أن يكون من خلال الجمع بين المؤقت وآخر وقت للنشاط.

هكذا مثل هذا:

1. في onCreate(Bundle saveInstanceState) ابدأ مؤقتًا، على سبيل المثال، 5 دقائق

2. في onUserInteraction() فقط قم بتخزين الوقت الحالي

بسيطة جدا حتى الآن.

الآن عندما يقوم الموقت بعمل مثل هذا:

1. خذ الوقت الحالي واطرح وقت التفاعل المخزن للحصول على timeDelta
2. إذا كانت قيمة timeDelta >= 5 دقائق، فقد انتهيت
3. إذا كانت قيمة timeDelta < 5 دقائق، فابدأ المؤقت مرة أخرى، ولكن هذه المرة استخدم 5 دقائق - الوقت المخزن.بمعنى آخر، 5 دقائق من التفاعل الأخير

Answer 12

كان لدي موقف مماثل للسؤال ، حيث كنت بحاجة إلى تتبع عدم نشاط المستخدم لمدة دقيقة واحدة ثم إعادة توجيه المستخدم لبدء النشاط ، كنت بحاجة أيضًا إلى مسح مكدس النشاط.

استنادا إلى 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: مكدس نشاط واضح

يجب أن تكون فئة المعالج ثابتة أو قد تحدث تسريبات

Answer 13

أفضل شيء هو التعامل مع هذا عبر تطبيقك بالكامل (على افتراض أن لديك أنشطة متعددة) من خلال التسجيل AppLifecycleCallbacks في CALSS التطبيق. يمكنك استخدام registerActivityLifecycleCallbacks() في فئة التطبيق مع عمليات الاسترجاعات التالية (أوصي بإنشاء فئة 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);
}

Answer 14

التعامل مع المستخدم في مهلة التفاعل في كوتلين:

     //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 reset() {
      timeoutHandler!!.removeCallbacks(interactionTimeoutRunnable);
      timeoutHandler!!.postDelayed(interactionTimeoutRunnable, 10*1000); //for 10 second

}

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

Answer 15

فيما يلي الحل الكامل الذي يتولى عدم نشاط المستخدم بعد بضع دقائق (على سبيل المثال 3 دقائق). هذا يحل المشكلات الشائعة مثل النشاط القفز إلى المقدمة عندما يكون التطبيق في الخلفية عند وقت الخروج.

أولاً ، نقوم بإنشاء نشاط يمكن أن يمتد جميع النشاطات الأخرى.

هذا هو رمز 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();
        }

    }

}

بعد ذلك ، نقوم بإنشاء واجهة لـ "مستمع تسجيل الدخول" لدينا

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>