Question

我正在尝试集成显示的引脚条目活动，并且只要用户打开应用程序就需要输入。包括将应用程序发送到后台然后将其带到前台。

此问题突出了检测应用何时发送到后台的方法：How to detect when an Android app goes to the background and come back to the foreground

我可以使用此处的方法并检查应用程序是否转到后台。然后在onResume（）方法中，如果应用程序不在前台，我可以启动引脚输入活动。

鉴于这是一个用于提高安全性的引脚输入活动，会以这种方式强制启动活动是否可靠（有没有其他方法我忽略了用户可以打开应用程序）？

Answer 1

使用Foreground.java类检查app是前景还是后台

package com.mindsetapp;

   import java.util.List;
   import java.util.concurrent.CopyOnWriteArrayList;

   import android.app.Activity;
   import android.app.Application;
   import android.content.Context;
   import android.os.Bundle;
   import android.os.Handler;
   import android.util.Log;


public class Foreground implements Application.ActivityLifecycleCallbacks {

public static final long CHECK_DELAY = 500;
public static final String TAG = Foreground.class.getName();

public interface Listener {

    public void onBecameForeground();

    public void onBecameBackground();
}
private static Foreground instance;
private boolean foreground = false, paused = true;
private Handler handler = new Handler();
private List<Listener> listeners = new CopyOnWriteArrayList<Listener>();
private Runnable check;

/**
 * Its not strictly necessary to use this method - _usually_ invoking
 * get with a Context gives us a path to retrieve the Application and
 * initialise, but sometimes (e.g. in test harness) the ApplicationContext
 * is != the Application, and the docs make no guarantees.
 *
 * @param application
 * @return an initialised Foreground instance
 */
public static Foreground init(Application application){
    if (instance == null) {
        instance = new Foreground();
        application.registerActivityLifecycleCallbacks(instance);
    }
    return instance;
}

public static Foreground get(Application application){
    if (instance == null) {
        init(application);
    }
    return instance;
}

public static Foreground get(Context ctx){
    if (instance == null) {
        Context appCtx = ctx.getApplicationContext();
        if (appCtx instanceof Application) {
            init((Application)appCtx);
        }
        throw new IllegalStateException(
                "Foreground is not initialised and " +
                        "cannot obtain the Application object");
    }
    return instance;
}

public static Foreground get(){
    if (instance == null) {
        throw new IllegalStateException(
                "Foreground is not initialised - invoke " +
                "at least once with parameterised init/get");
    }
    return instance;
}

public boolean isForeground(){
    return foreground;
}

public boolean isBackground(){
    return !foreground;
}

public void addListener(Listener listener){
    listeners.add(listener);
}

public void removeListener(Listener listener){
    listeners.remove(listener);
}

@Override
public void onActivityResumed(Activity activity) {
    paused = false;
    boolean wasBackground = !foreground;
    foreground = true;

    if (check != null)
        handler.removeCallbacks(check);
    try {


        if (wasBackground){
            Log.i(TAG, "went foreground");
            if (!MindSetApp.flag_mute) {


            MindSetApp.sound_flag=true;
            if( MindSetApp.sound_flag)
            {
                if(!MindSetApp.mPlayer.isPlaying())
                {
                    MindSetApp.mPlayer.start();
                }
            }
            }

            for (Listener l : listeners) {
                try {
                    l.onBecameForeground();
                } catch (Exception exc) {
                    Log.e(TAG, "Listener threw exception!", exc);
                }
            }
        } else {
            Log.i(TAG, "still foreground");

        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}
@Override
public void onActivityPaused(Activity activity) {
    paused = true;

    if (check != null)
        handler.removeCallbacks(check);

    handler.postDelayed(check = new Runnable(){
        @Override
        public void run() {
            if (foreground && paused) {
                foreground = false;

                for (Listener l : listeners) {
                    try {
                        l.onBecameBackground();
                    } catch (Exception exc) {
                        Log.e(TAG, "Listener threw exception!", exc);
                    }
                }
            } else {
                Log.i(TAG, "still foreground"+MindSetApp.sound_flag);
            }
        }
    }, CHECK_DELAY);
}
@Override
public void onActivityCreated(Activity activity, Bundle savedInstanceState) {}

@Override
public void onActivityStarted(Activity activity) {}

@Override
public void onActivityStopped(Activity activity) {}

@Override
public void onActivitySaveInstanceState(Activity activity, Bundle outState) {}

@Override
public void onActivityDestroyed(Activity activity) {}
}

当应用程序到达前台时，有没有办法强制启动活动？

1 个答案: