使用 ActivityLifecycleCallbacks 自動記錄 Android 生命周期事件？

Question

我正在嘗試使用 ActivityLifecycleCallbacks 自動捕獲和記錄 Android 生命周期事件，但是至少可以說，關於此事的文檔很少：

    public void registerActivityLifecycleCallbacks (Application.ActivityLifecycleCallbacks callback)

我不想擴展 Activity 類或覆蓋現有的生命周期方法（onCreate、onResume 等...）我希望有一個單獨的類來監聽這些事件並采取相應的行動。

有沒有人在這方面有任何經驗，或者有關於它是如何工作的良好可靠文檔或教程的鏈接？ 具體來說，如何注冊ActivityLifecycleCallbacks，以及如何處理？

Answer 1

我沒有任何第一手經驗，但從 API 來看，您可以編寫自己的類來實現Application.ActivityLifecycleCallbacks接口並在提供的Application類實例上注冊該類

getApplicaton().registerActivityLifecycleCallbacks(yourCustomClass);

此類將收到與您的個人活動相同的回調。 祝你好運。

附注。 順便說一句，這是 API 級別 14，因此它不適用於舊手機。

Answer 2

我自己實現了Application.ActivityLifecycleCallbacks 。 我正在使用SherlockActivity ，但對於普通的 Activity 類可能會起作用。

首先，我正在創建一個接口，其中包含用於跟蹤活動生命周期的所有方法：

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

其次，我在我的應用程序類中實現了這個接口：

public class MyApplication extends Application implements my.package.ActivityLifecycleCallbacks{

    @Override
    public void onCreate() {
        super.onCreate();           
    }

    @Override
    public void onActivityStopped(Activity activity) {
        Log.i("Tracking Activity Stopped", activity.getLocalClassName());

    }

    @Override
    public void onActivityStarted(Activity activity) {
        Log.i("Tracking Activity Started", activity.getLocalClassName());

    }

    @Override
    public void onActivitySaveInstanceState(Activity activity, Bundle outState) {
        Log.i("Tracking Activity SaveInstanceState", activity.getLocalClassName());
    }

    @Override
    public void onActivityResumed(Activity activity) {
        Log.i("Tracking Activity Resumed", activity.getLocalClassName());
    }

    @Override
    public void onActivityPaused(Activity activity) {
        Log.i("Tracking Activity Paused", activity.getLocalClassName());
    }

    @Override
    public void onActivityDestroyed(Activity activity) {
        Log.i("Tracking Activity Destroyed", activity.getLocalClassName());
    }

    @Override
    public void onActivityCreated(Activity activity, Bundle savedInstanceState) {
        Log.i("Tracking Activity Created", activity.getLocalClassName());
    }
}

第三，我正在創建一個從 SherlockActivity 擴展的類：

public class MySherlockActivity extends SherlockActivity {

    protected MyApplication nMyApplication;

    protected void onCreate(Bundle savedInstanceState) {
        // TODO Auto-generated method stub
        super.onCreate(savedInstanceState);
        nMyApplication = (MyApplication) getApplication();
        nMyApplication.onActivityCreated(this, savedInstanceState);
    }

    protected void onResume() {
        // TODO Auto-generated method stub
        super.onResume();
        nMyApplication.onActivityResumed(this);
    }

    @Override
    protected void onPause() {
        // TODO Auto-generated method stub
        super.onPause();
        nMyApplication.onActivityPaused(this);
    }

    @Override
    protected void onDestroy() {
        // TODO Auto-generated method stub
        super.onDestroy();
        nMyApplication.onActivityDestroyed(this);
    }

    @Override
    protected void onStart() {
        super.onStart();
        nMyApplication.onActivityStarted(this);
    }

    @Override
    protected void onStop() {
        super.onStop();
        nMyApplication.onActivityStopped(this);
    }

    @Override
    protected void onSaveInstanceState(Bundle outState) {
        super.onSaveInstanceState(outState);
        nMyApplication.onActivitySaveInstanceState(this, outState);
    }   
}

第四，從 SherlockActivity 擴展的所有類，我替換為 MySherlockActivity：

public class MainActivity extends MySherlockActivity{

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

}

現在，在 logcat 中，您將看到在 MyApplication 中制作的接口實現中編程的日志。

更新

此實現已從 API 級別 9 (Gingerbread)、API 級別 12 (Honeycomb) 和 API 級別 17 (Jelly Bean) 測試，並且工作正常。 可能適用於 Android 的舊版本。

Answer 3

@Override
public void onCreate() {
    super.onCreate();
    registerActivityLifecycleCallbacks(MyApplication.this/*(Your Application Name)*/);
}

只在 Application 類上添加這一行，一切正常。

Answer 4

試試這個： http : //engineering.meetme.com/2015/04/android-determine-when-app-is-opened-or-closed/#comment-202

它提出了一個AppForegroundStateManager ，每個活動通過其onStop()和onStart()函數向其報告，如下所示：

@Override
protected void onStart() {
    super.onStart();
    AppForegroundStateManager.getInstance().onActivityVisible(this);
}

@Override
protected void onStop() {
    AppForegroundStateManager.getInstance().onActivityNotVisible(this);
    super.onStop();
}

您的Application類實現了一個這樣的監聽器：

public class MyApplication extends Application {
    @Override
    public void onCreate() {
        super.onCreate();
        AppForegroundStateManager.getInstance().addListener(this);
    }

    @Override
    public void onAppForegroundStateChange(AppForegroundStateManager.AppForegroundState newState) {
        if (AppForegroundStateManager.AppForegroundState.IN_FOREGROUND.equals(newState)) {
            // App just entered the foreground. Do something here!
            Log.i(TAG, "App Just Entered the Foreground with launch mechanism of: " + mLaunchMechanism);
        } else {
            // App just entered the background. Set our launch mode back to the default of direct.
            mLaunchMechanism = LaunchMechanism.DIRECT;
        }
    }
}

它還包括用於確定應用程序打開方式的提示和技巧 - 從通知、打開應用程序的 URL 或直接從應用程序菜單。 這是通過 Application 類中的Enum完成的：

public enum LaunchMechanism {
    DIRECT,
    NOTIFICATION,
    URL,
    BACKGROUND
}

private LaunchMechanism mLaunchMechanism = LaunchMechanism.DIRECT;

public void setLaunchMechanism(LaunchMechanism launchMechanism) {
    mLaunchMechanism = launchMechanism;
}

在我們的實現中，當我們啟動將啟動第三方 Activity 的 Activity 時，我們有標志，例如用戶是否從我們的應用程序撥打電話或啟動瀏覽器。 在啟動活動的onStop()我們然后進行這樣的檢查，以便僅在這些標志為 false 時報告活動的不可見性：

if(!flag_userLaunchedThirdPartyActivity){
     AppForegroundStateManager.getInstance().onActivityNotVisible(this);
     }

為了檢查應用程序是否進入后台 - 例如當設備的屏幕變暗或用戶接到電話時 - 它的工作方式如下：

public static boolean isApplicationGoingToBackground(final Context context) {

    ActivityManager am = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
    List<RunningTaskInfo> tasks = am.getRunningTasks(1);
    if (!tasks.isEmpty()) {
        ComponentName topActivity = tasks.get(0).topActivity;
        if (!topActivity.getPackageName().equals(context.getPackageName())) {
            setLaunchMechanism(LaunchMechanism.BACKGROUND);
            return true;
        }
    }

    setLaunchMechanism(LaunchMechanism.DIRECT);
    return false;
}

此解決方案不依賴於 API 級別，因此它應該一直工作到 API 級別 1。