Merge "Update call log cache when annotated call log is updated." am: 1004ab9533 (396a5329) · Commits · e / os / android_packages_apps_Dialer

java/com/android/dialer/calllog/CallLogCacheUpdater.java

0 → 100644

+129 −0

Original line number	Original line	Diff line number	Diff line
			/*
			* Copyright (C) 2018 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.dialer.calllog;

			import android.content.ContentProviderOperation;
			import android.content.ContentUris;
			import android.content.ContentValues;
			import android.content.Context;
			import android.content.OperationApplicationException;
			import android.os.RemoteException;
			import android.provider.CallLog;
			import android.provider.CallLog.Calls;
			import android.provider.ContactsContract.CommonDataKinds.Phone;
			import com.android.dialer.DialerPhoneNumber;
			import com.android.dialer.NumberAttributes;
			import com.android.dialer.calllog.database.contract.AnnotatedCallLogContract.AnnotatedCallLog;
			import com.android.dialer.calllog.datasources.CallLogMutations;
			import com.android.dialer.common.LogUtil;
			import com.android.dialer.common.concurrent.Annotations.BackgroundExecutor;
			import com.android.dialer.inject.ApplicationContext;
			import com.android.dialer.protos.ProtoParsers;
			import com.google.common.util.concurrent.ListenableFuture;
			import com.google.common.util.concurrent.ListeningExecutorService;
			import java.util.ArrayList;
			import java.util.Arrays;
			import java.util.stream.Stream;
			import javax.inject.Inject;

			/**
			* Update {@link Calls#CACHED_NAME} and other cached columns after the annotated call log has been
			* updated. Dialer does not read these columns but other apps relies on it.
			*/
			@SuppressWarnings("AndroidApiChecker")
			public final class CallLogCacheUpdater {

			private final Context appContext;
			private final ListeningExecutorService backgroundExecutor;

			@Inject
			CallLogCacheUpdater(
			@ApplicationContext Context appContext,
			@BackgroundExecutor ListeningExecutorService backgroundExecutor) {
			this.appContext = appContext;
			this.backgroundExecutor = backgroundExecutor;
			}

			/**
			* Extracts inserts and updates from {@code mutations} to update the 'cached' columns in the
			* system call log.
			*
			* <p>If the cached columns are non-empty, it will only be updated if {@link Calls#CACHED_NAME}
			* has changed
			*/
			public ListenableFuture<Void> updateCache(CallLogMutations mutations) {
			return backgroundExecutor.submit(
			() -> {
			updateCacheInternal(mutations);
			return null;
			});
			}

			private void updateCacheInternal(CallLogMutations mutations) {
			ArrayList<ContentProviderOperation> operations = new ArrayList<>();
			Stream.concat(
			mutations.getInserts().entrySet().stream(), mutations.getUpdates().entrySet().stream())
			.forEach(
			entry -> {
			ContentValues values = entry.getValue();
			if (!values.containsKey(AnnotatedCallLog.NUMBER_ATTRIBUTES)
			\|\| !values.containsKey(AnnotatedCallLog.NUMBER)) {
			return;
			}
			DialerPhoneNumber dialerPhoneNumber =
			ProtoParsers.getTrusted(
			values, AnnotatedCallLog.NUMBER, DialerPhoneNumber.getDefaultInstance());
			NumberAttributes numberAttributes =
			ProtoParsers.getTrusted(
			values,
			AnnotatedCallLog.NUMBER_ATTRIBUTES,
			NumberAttributes.getDefaultInstance());
			operations.add(
			ContentProviderOperation.newUpdate(
			ContentUris.withAppendedId(Calls.CONTENT_URI, entry.getKey()))
			.withValue(
			Calls.CACHED_FORMATTED_NUMBER,
			values.getAsString(AnnotatedCallLog.FORMATTED_NUMBER))
			.withValue(Calls.CACHED_LOOKUP_URI, numberAttributes.getLookupUri())
			// Calls.CACHED_MATCHED_NUMBER is not available.
			.withValue(Calls.CACHED_NAME, numberAttributes.getName())
			.withValue(
			Calls.CACHED_NORMALIZED_NUMBER, dialerPhoneNumber.getNormalizedNumber())
			.withValue(Calls.CACHED_NUMBER_LABEL, numberAttributes.getNumberTypeLabel())
			// NUMBER_TYPE is lost in NumberAttributes when it is converted to a string
			// label, Use TYPE_CUSTOM so the label will be displayed.
			.withValue(Calls.CACHED_NUMBER_TYPE, Phone.TYPE_CUSTOM)
			.withValue(Calls.CACHED_PHOTO_ID, numberAttributes.getPhotoId())
			.withValue(Calls.CACHED_PHOTO_URI, numberAttributes.getPhotoUri())
			// Avoid writing to the call log for insignificant changes to avoid triggering
			// other content observers such as the voicemail client.
			.withSelection(
			Calls.CACHED_NAME + " IS NOT ?",
			new String[] {numberAttributes.getName()})
			.build());
			});
			try {
			int count =
			Arrays.stream(appContext.getContentResolver().applyBatch(CallLog.AUTHORITY, operations))
			.mapToInt(result -> result.count)
			.sum();
			LogUtil.i("CallLogCacheUpdater.updateCache", "updated %d rows", count);
			} catch (OperationApplicationException \| RemoteException e) {
			throw new IllegalStateException(e);
			}
			}
			}

java/com/android/dialer/calllog/RefreshAnnotatedCallLogWorker.java

+12 −0

Original line number	Original line	Diff line number	Diff line
	@@ -26,6 +26,7 @@ import com.android.dialer.calllog.datasources.DataSources;
	import com.android.dialer.common.LogUtil;		import com.android.dialer.common.LogUtil;
	import com.android.dialer.common.concurrent.Annotations.BackgroundExecutor;		import com.android.dialer.common.concurrent.Annotations.BackgroundExecutor;
	import com.android.dialer.common.concurrent.Annotations.LightweightExecutor;		import com.android.dialer.common.concurrent.Annotations.LightweightExecutor;
			import com.android.dialer.common.concurrent.DefaultFutureCallback;
	import com.android.dialer.common.concurrent.DialerFutureSerializer;		import com.android.dialer.common.concurrent.DialerFutureSerializer;
	import com.android.dialer.common.concurrent.DialerFutures;		import com.android.dialer.common.concurrent.DialerFutures;
	import com.android.dialer.inject.ApplicationContext;		import com.android.dialer.inject.ApplicationContext;
	@@ -53,6 +54,7 @@ public class RefreshAnnotatedCallLogWorker {
	private final MutationApplier mutationApplier;		private final MutationApplier mutationApplier;
	private final FutureTimer futureTimer;		private final FutureTimer futureTimer;
	private final CallLogState callLogState;		private final CallLogState callLogState;
			private final CallLogCacheUpdater callLogCacheUpdater;
	private final ListeningExecutorService backgroundExecutorService;		private final ListeningExecutorService backgroundExecutorService;
	private final ListeningExecutorService lightweightExecutorService;		private final ListeningExecutorService lightweightExecutorService;
	// Used to ensure that only one refresh flow runs at a time. (Note that		// Used to ensure that only one refresh flow runs at a time. (Note that
	@@ -67,6 +69,7 @@ public class RefreshAnnotatedCallLogWorker {
	MutationApplier mutationApplier,		MutationApplier mutationApplier,
	FutureTimer futureTimer,		FutureTimer futureTimer,
	CallLogState callLogState,		CallLogState callLogState,
			CallLogCacheUpdater callLogCacheUpdater,
	@BackgroundExecutor ListeningExecutorService backgroundExecutorService,		@BackgroundExecutor ListeningExecutorService backgroundExecutorService,
	@LightweightExecutor ListeningExecutorService lightweightExecutorService) {		@LightweightExecutor ListeningExecutorService lightweightExecutorService) {
	this.appContext = appContext;		this.appContext = appContext;
	@@ -75,6 +78,7 @@ public class RefreshAnnotatedCallLogWorker {
	this.mutationApplier = mutationApplier;		this.mutationApplier = mutationApplier;
	this.futureTimer = futureTimer;		this.futureTimer = futureTimer;
	this.callLogState = callLogState;		this.callLogState = callLogState;
			this.callLogCacheUpdater = callLogCacheUpdater;
	this.backgroundExecutorService = backgroundExecutorService;		this.backgroundExecutorService = backgroundExecutorService;
	this.lightweightExecutorService = lightweightExecutorService;		this.lightweightExecutorService = lightweightExecutorService;
	}		}
	@@ -206,6 +210,14 @@ public class RefreshAnnotatedCallLogWorker {
	},		},
	lightweightExecutorService);		lightweightExecutorService);

			Futures.addCallback(
			Futures.transformAsync(
			applyMutationsFuture,
			unused -> callLogCacheUpdater.updateCache(mutations),
			MoreExecutors.directExecutor()),
			new DefaultFutureCallback<>(),
			MoreExecutors.directExecutor());

	// After mutations applied, call onSuccessfulFill for each data source (in parallel).		// After mutations applied, call onSuccessfulFill for each data source (in parallel).
	ListenableFuture<List<Void>> onSuccessfulFillFuture =		ListenableFuture<List<Void>> onSuccessfulFillFuture =
	Futures.transformAsync(		Futures.transformAsync(

java/com/android/dialer/protos/ProtoParsers.java

+34 −1

Original line number	Original line	Diff line number	Diff line
	@@ -16,6 +16,7 @@

	package com.android.dialer.protos;		package com.android.dialer.protos;

			import android.content.ContentValues;
	import android.content.Intent;		import android.content.Intent;
	import android.os.Bundle;		import android.os.Bundle;
	import android.support.annotation.NonNull;		import android.support.annotation.NonNull;
	@@ -42,10 +43,27 @@ public final class ProtoParsers {
	return (T) mergeFrom(bytes, defaultInstance.getDefaultInstanceForType());		return (T) mergeFrom(bytes, defaultInstance.getDefaultInstanceForType());
	}		}

			/**
			* Retrieve a proto from a ContentValues which was not created within the current
			* executable/version.
			*/
			@SuppressWarnings("unchecked") // We want to eventually optimize away parser classes, so cast
			public static <T extends MessageLite> T get(
			@NonNull ContentValues contentValues, @NonNull String key, @NonNull T defaultInstance)
			throws InvalidProtocolBufferException {

			Assert.isNotNull(contentValues);
			Assert.isNotNull(key);
			Assert.isNotNull(defaultInstance);

			byte[] bytes = contentValues.getAsByteArray(key);
			return (T) mergeFrom(bytes, defaultInstance.getDefaultInstanceForType());
			}

	/**		/**
	* Retrieve a proto from a trusted bundle which was created within the current executable/version.		* Retrieve a proto from a trusted bundle which was created within the current executable/version.
	*		*
	* @throws RuntimeException if the proto cannot be parsed		* @throws IllegalStateException if the proto cannot be parsed
	*/		*/
	public static <T extends MessageLite> T getTrusted(		public static <T extends MessageLite> T getTrusted(
	@NonNull Bundle bundle, @NonNull String key, @NonNull T defaultInstance) {		@NonNull Bundle bundle, @NonNull String key, @NonNull T defaultInstance) {
	@@ -56,6 +74,21 @@ public final class ProtoParsers {
	}		}
	}		}

			/**
			* Retrieve a proto from a trusted ContentValues which was created within the current
			* executable/version.
			*
			* @throws IllegalStateException if the proto cannot be parsed
			*/
			public static <T extends MessageLite> T getTrusted(
			@NonNull ContentValues contentValues, @NonNull String key, @NonNull T defaultInstance) {
			try {
			return get(contentValues, key, defaultInstance);
			} catch (InvalidProtocolBufferException e) {
			throw Assert.createIllegalStateFailException(e.toString());
			}
			}

	/**		/**
	* Retrieve a proto from a trusted bundle which was created within the current executable/version.		* Retrieve a proto from a trusted bundle which was created within the current executable/version.
	*		*