Introduce PersistentConnectionManager. (dc24107b) · Commits · e / os / android_frameworks_base

packages/SystemUI/src/com/android/systemui/util/service/Observer.java

0 → 100644

+45 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2022 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		package com.android.systemui.util.service;

		/**
		* The {@link Observer} interface specifies an entity which listeners
		* can be informed of changes to the source, which will require updating. Note that this deals
		* with changes to the source itself, not content which will be updated through the interface.
		*/
		public interface Observer {
		/**
		* Callback for receiving updates from the {@link Observer}.
		*/
		interface Callback {
		/**
		* Invoked when the source has changed.
		*/
		void onSourceChanged();
		}

		/**
		* Adds a callback to receive future updates from the {@link Observer}.
		*/
		void addCallback(Callback callback);

		/**
		* Removes a callback from receiving further updates.
		* @param callback
		*/
		void removeCallback(Callback callback);
		}

packages/SystemUI/src/com/android/systemui/util/service/PackageObserver.java

0 → 100644

+107 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2022 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		package com.android.systemui.util.service;

		import android.content.BroadcastReceiver;
		import android.content.ComponentName;
		import android.content.Context;
		import android.content.Intent;
		import android.content.IntentFilter;
		import android.os.PatternMatcher;
		import android.util.Log;

		import com.android.systemui.communal.CommunalSource;

		import com.google.android.collect.Lists;

		import java.lang.ref.WeakReference;
		import java.util.ArrayList;
		import java.util.Iterator;

		import javax.inject.Inject;

		/**
		* {@link PackageObserver} allows for monitoring the system for changes relating to a particular
		* package. This can be used by {@link CommunalSource} clients to detect when a related package
		* has changed and reloading is necessary.
		*/
		public class PackageObserver implements Observer {
		private static final String TAG = "PackageObserver";
		private static final boolean DEBUG = Log.isLoggable(TAG, Log.DEBUG);

		private final ArrayList<WeakReference<Callback>> mCallbacks = Lists.newArrayList();

		private final BroadcastReceiver mReceiver = new BroadcastReceiver() {
		@Override
		public void onReceive(Context context, Intent intent) {
		if (DEBUG) {
		Log.d(TAG, "package added receiver - onReceive");
		}

		final Iterator<WeakReference<Callback>> iter = mCallbacks.iterator();
		while (iter.hasNext()) {
		final Callback callback = iter.next().get();
		if (callback != null) {
		callback.onSourceChanged();
		} else {
		iter.remove();
		}
		}
		}
		};

		private final String mPackageName;
		private final Context mContext;

		@Inject
		public PackageObserver(Context context, ComponentName component) {
		mContext = context;
		mPackageName = component.getPackageName();
		}

		@Override
		public void addCallback(Callback callback) {
		if (DEBUG) {
		Log.d(TAG, "addCallback:" + callback);
		}
		mCallbacks.add(new WeakReference<>(callback));

		// Only register for listening to package additions on first callback.
		if (mCallbacks.size() > 1) {
		return;
		}

		final IntentFilter filter = new IntentFilter(Intent.ACTION_PACKAGE_ADDED);
		filter.addDataScheme("package");
		filter.addDataSchemeSpecificPart(mPackageName, PatternMatcher.PATTERN_LITERAL);
		// Note that we directly register the receiver here as data schemes are not supported by
		// BroadcastDispatcher.
		mContext.registerReceiver(mReceiver, filter, Context.RECEIVER_EXPORTED);
		}

		@Override
		public void removeCallback(Callback callback) {
		if (DEBUG) {
		Log.d(TAG, "removeCallback:" + callback);
		}
		final boolean removed = mCallbacks.removeIf(el -> el.get() == callback);

		if (removed && mCallbacks.isEmpty()) {
		mContext.unregisterReceiver(mReceiver);
		}
		}
		}

packages/SystemUI/src/com/android/systemui/util/service/PersistentConnectionManager.java

0 → 100644

+155 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2022 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		package com.android.systemui.util.service;

		import static com.android.systemui.util.service.dagger.ObservableServiceModule.BASE_RECONNECT_DELAY_MS;
		import static com.android.systemui.util.service.dagger.ObservableServiceModule.MAX_RECONNECT_ATTEMPTS;
		import static com.android.systemui.util.service.dagger.ObservableServiceModule.MIN_CONNECTION_DURATION_MS;
		import static com.android.systemui.util.service.dagger.ObservableServiceModule.OBSERVER;
		import static com.android.systemui.util.service.dagger.ObservableServiceModule.SERVICE_CONNECTION;

		import android.util.Log;

		import com.android.systemui.util.concurrency.DelayableExecutor;
		import com.android.systemui.util.time.SystemClock;

		import javax.inject.Inject;
		import javax.inject.Named;

		/**
		* The {@link PersistentConnectionManager} is responsible for maintaining a connection to a
		* {@link ObservableServiceConnection}.
		* @param <T> The transformed connection type handled by the service.
		*/
		public class PersistentConnectionManager<T> {
		private static final String TAG = "PersistentConnManager";
		private static final boolean DEBUG = Log.isLoggable(TAG, Log.DEBUG);

		private final SystemClock mSystemClock;
		private final DelayableExecutor mMainExecutor;
		private final int mBaseReconnectDelayMs;
		private final int mMaxReconnectAttempts;
		private final int mMinConnectionDuration;
		private final Observer mObserver;

		private int mReconnectAttempts = 0;
		private Runnable mCurrentReconnectCancelable;

		private final ObservableServiceConnection<T> mConnection;

		private final Runnable mConnectRunnable = new Runnable() {
		@Override
		public void run() {
		mCurrentReconnectCancelable = null;
		mConnection.bind();
		}
		};

		private final Observer.Callback mObserverCallback = () -> initiateConnectionAttempt();

		private final ObservableServiceConnection.Callback mConnectionCallback =
		new ObservableServiceConnection.Callback() {
		private long mStartTime;

		@Override
		public void onConnected(ObservableServiceConnection connection, Object proxy) {
		mStartTime = mSystemClock.currentTimeMillis();
		}

		@Override
		public void onDisconnected(ObservableServiceConnection connection, int reason) {
		if (mSystemClock.currentTimeMillis() - mStartTime > mMinConnectionDuration) {
		initiateConnectionAttempt();
		} else {
		scheduleConnectionAttempt();
		}
		}
		};

		@Inject
		public PersistentConnectionManager(
		SystemClock clock,
		DelayableExecutor mainExecutor,
		@Named(SERVICE_CONNECTION) ObservableServiceConnection<T> serviceConnection,
		@Named(MAX_RECONNECT_ATTEMPTS) int maxReconnectAttempts,
		@Named(BASE_RECONNECT_DELAY_MS) int baseReconnectDelayMs,
		@Named(MIN_CONNECTION_DURATION_MS) int minConnectionDurationMs,
		@Named(OBSERVER) Observer observer) {
		mSystemClock = clock;
		mMainExecutor = mainExecutor;
		mConnection = serviceConnection;
		mObserver = observer;

		mMaxReconnectAttempts = maxReconnectAttempts;
		mBaseReconnectDelayMs = baseReconnectDelayMs;
		mMinConnectionDuration = minConnectionDurationMs;
		}

		/**
		* Begins the {@link PersistentConnectionManager} by connecting to the associated service.
		*/
		public void start() {
		mConnection.addCallback(mConnectionCallback);
		mObserver.addCallback(mObserverCallback);
		initiateConnectionAttempt();
		}

		/**
		* Brings down the {@link PersistentConnectionManager}, disconnecting from the service.
		*/
		public void stop() {
		mConnection.removeCallback(mConnectionCallback);
		mObserver.removeCallback(mObserverCallback);
		mConnection.unbind();
		}

		private void initiateConnectionAttempt() {
		// Reset attempts
		mReconnectAttempts = 0;

		// The first attempt is always a direct invocation rather than delayed.
		mConnection.bind();
		}

		private void scheduleConnectionAttempt() {
		// always clear cancelable if present.
		if (mCurrentReconnectCancelable != null) {
		mCurrentReconnectCancelable.run();
		mCurrentReconnectCancelable = null;
		}

		if (mReconnectAttempts >= mMaxReconnectAttempts) {
		if (DEBUG) {
		Log.d(TAG, "exceeded max connection attempts.");
		}
		return;
		}

		final long reconnectDelayMs =
		(long) Math.scalb(mBaseReconnectDelayMs, mReconnectAttempts);

		if (DEBUG) {
		Log.d(TAG,
		"scheduling connection attempt in " + reconnectDelayMs + "milliseconds");
		}

		mCurrentReconnectCancelable = mMainExecutor.executeDelayed(mConnectRunnable,
		reconnectDelayMs);

		mReconnectAttempts++;
		}
		}

packages/SystemUI/src/com/android/systemui/util/service/dagger/ObservableServiceModule.java

0 → 100644

+65 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2022 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/


		package com.android.systemui.util.service.dagger;

		import android.content.res.Resources;

		import com.android.systemui.R;
		import com.android.systemui.dagger.qualifiers.Main;

		import javax.inject.Named;

		import dagger.Module;
		import dagger.Provides;

		/**
		* Module containing components and parameters for
		* {@link com.android.systemui.util.service.ObservableServiceConnection}
		* and {@link com.android.systemui.util.service.PersistentConnectionManager}.
		*/
		@Module(subcomponents = {
		PackageObserverComponent.class,
		})
		public class ObservableServiceModule {
		public static final String MAX_RECONNECT_ATTEMPTS = "max_reconnect_attempts";
		public static final String BASE_RECONNECT_DELAY_MS = "base_reconnect_attempts";
		public static final String MIN_CONNECTION_DURATION_MS = "min_connection_duration_ms";
		public static final String SERVICE_CONNECTION = "service_connection";
		public static final String OBSERVER = "observer";

		@Provides
		@Named(MAX_RECONNECT_ATTEMPTS)
		static int providesMaxReconnectAttempts(@Main Resources resources) {
		return resources.getInteger(
		R.integer.config_communalSourceMaxReconnectAttempts);
		}

		@Provides
		@Named(BASE_RECONNECT_DELAY_MS)
		static int provideBaseReconnectDelayMs(@Main Resources resources) {
		return resources.getInteger(
		R.integer.config_communalSourceReconnectBaseDelay);
		}

		@Provides
		@Named(MIN_CONNECTION_DURATION_MS)
		static int providesMinConnectionDuration(@Main Resources resources) {
		return resources.getInteger(
		R.integer.config_connectionMinDuration);
		}
		}

packages/SystemUI/src/com/android/systemui/util/service/dagger/PackageObserverComponent.java

0 → 100644

+42 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2022 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/
		package com.android.systemui.util.service.dagger;

		import android.content.ComponentName;

		import com.android.systemui.util.service.PackageObserver;

		import dagger.BindsInstance;
		import dagger.Subcomponent;

		/**
		* Generates a scoped {@link PackageObserver}.
		*/
		@Subcomponent
		public interface PackageObserverComponent {
		/**
		* Generates a {@link PackageObserverComponent} instance.
		*/
		@Subcomponent.Factory
		interface Factory {
		PackageObserverComponent create(@BindsInstance ComponentName component);
		}

		/**
		* Creates a {@link PackageObserver}.
		*/
		PackageObserver getPackageObserver();
		}