Android中如何在Service中实现ViewTreeObserver.OnWindowFocusChangeListener？求其他方式

Hey there! Let's break this down clearly first: a Service doesn't have its own associated Window or View hierarchy by default. That’s why your Java code compiles without errors but the listener never actually triggers—there’s no View/Window for it to observe.

But don’t worry, there are practical ways to achieve window focus monitoring from a Service, depending on your use case. Here are the most reliable approaches:

1. Bind to an Activity's View (App-Specific Focus) #

If your Service works with an Activity in your app, you can use a binding connection to get a reference to the Activity’s root View, then attach the listener to that View’s ViewTreeObserver. Just be sure to use weak references to avoid memory leaks.

Example code:

// In your Service
private WeakReference<MainActivity> mActivityRef;
private ViewTreeObserver.OnWindowFocusChangeListener mFocusListener = hasFocus -> {
    if (hasFocus) {
        Log.d("ServiceFocus", "Activity window gained focus");
        // Add your focus-gained logic here
    } else {
        Log.d("ServiceFocus", "Activity window lost focus");
        // Add your focus-lost logic here
    }
};

@Override
public IBinder onBind(Intent intent) {
    return new LocalBinder();
}

public class LocalBinder extends Binder {
    public MyService getService() {
        return MyService.this;
    }
}

// Call this from your Activity after binding successfully
public void attachActivityView(MainActivity activity) {
    mActivityRef = new WeakReference<>(activity);
    View rootView = activity.getWindow().getDecorView().getRootView();
    rootView.getViewTreeObserver().addOnWindowFocusChangeListener(mFocusListener);
}

// Clean up the listener to prevent leaks when the Service is destroyed
@Override
public void onDestroy() {
    super.onDestroy();
    if (mActivityRef != null && mActivityRef.get() != null) {
        View rootView = mActivityRef.get().getWindow().getDecorView().getRootView();
        rootView.getViewTreeObserver().removeOnWindowFocusChangeListener(mFocusListener);
    }
}

2. Use AccessibilityService (Global Window Focus Monitoring) #

If you need to track focus changes across all apps/windows on the device, AccessibilityService is the official, supported approach. It’s built to listen to system-wide UI events, including window focus shifts.

Step 1: Declare the Service in AndroidManifest.xml #

<service
    android:name=".MyAccessibilityService"
    android:permission="android.permission.BIND_ACCESSIBILITY_SERVICE">
    <intent-filter>
        <action android:name="android.accessibilityservice.AccessibilityService" />
    </intent-filter>
    <meta-data
        android:name="android.accessibilityservice"
        android:resource="@xml/accessibility_service_config" />
</service>

Step 2: Create the Accessibility Config (res/xml/accessibility_service_config.xml) #

<?xml version="1.0" encoding="utf-8"?>
<accessibility-service xmlns:android="http://schemas.android.com/apk/res/android"
    android:accessibilityEventTypes="typeWindowFocused|typeWindowStateChanged"
    android:accessibilityFeedbackType="feedbackGeneric"
    android:accessibilityFlags="flagDefault"
    android:canRetrieveWindowContent="true" />

Step 3: Implement the AccessibilityService #

public class MyAccessibilityService extends AccessibilityService {
    @Override
    public void onAccessibilityEvent(AccessibilityEvent event) {
        int eventType = event.getEventType();
        if (eventType == AccessibilityEvent.TYPE_WINDOW_FOCUSED) {
            String focusedPackage = event.getPackageName().toString();
            Log.d("GlobalFocus", "Focused window belongs to: " + focusedPackage);
            // Add your global focus logic here
        }
    }

    @Override
    public void onInterrupt() {
        // Required empty method
    }
}

Note: Users will need to enable your accessibility service in their device settings (Settings > Accessibility) for this to function.

3. Add a Floating Window (Service-Owned View Focus) #

If your Service needs its own View to monitor focus (e.g., a floating widget), use WindowManager to add a transparent/hidden View to the screen, then attach the listener to it. This requires the SYSTEM_ALERT_WINDOW permission.

Example code:

public class MyService extends Service {
    private WindowManager mWindowManager;
    private View mFloatingView;
    private ViewTreeObserver.OnWindowFocusChangeListener mFocusListener = hasFocus -> {
        if (hasFocus) {
            Log.d("FloatingFocus", "Floating window gained focus");
        } else {
            Log.d("FloatingFocus", "Floating window lost focus");
        }
    };

    @Override
    public void onCreate() {
        super.onCreate();
        mWindowManager = (WindowManager) getSystemService(WINDOW_SERVICE);
        
        // Create a transparent, non-intrusive View
        mFloatingView = new View(this);
        mFloatingView.setBackgroundColor(Color.TRANSPARENT);
        
        // Configure window parameters
        WindowManager.LayoutParams params = new WindowManager.LayoutParams(
                WindowManager.LayoutParams.WRAP_CONTENT,
                WindowManager.LayoutParams.WRAP_CONTENT,
                Build.VERSION.SDK_INT >= Build.VERSION_CODES.O ?
                        WindowManager.LayoutParams.TYPE_APPLICATION_OVERLAY :
                        WindowManager.LayoutParams.TYPE_PHONE,
                WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE | WindowManager.LayoutParams.FLAG_LAYOUT_IN_SCREEN,
                PixelFormat.TRANSLUCENT);
        
        // Add the View to the screen
        mWindowManager.addView(mFloatingView, params);
        
        // Attach the focus listener
        mFloatingView.getViewTreeObserver().addOnWindowFocusChangeListener(mFocusListener);
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        if (mFloatingView != null) {
            mFloatingView.getViewTreeObserver().removeOnWindowFocusChangeListener(mFocusListener);
            mWindowManager.removeView(mFloatingView);
        }
    }

    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }
}

Note: For Android 6.0+, you need to request the SYSTEM_ALERT_WINDOW permission via the settings intent (Settings.ACTION_MANAGE_OVERLAY_PERMISSION).

内容的提问来源于stack exchange，提问作者perhaps 2me