112 lines
3.9 KiB
Java
112 lines
3.9 KiB
Java
/*
|
|
* Copyright (C) 2016 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.incallui.legacyblocking;
|
|
|
|
import android.content.Context;
|
|
import android.database.ContentObserver;
|
|
import android.os.Handler;
|
|
import android.provider.CallLog;
|
|
import android.support.annotation.NonNull;
|
|
import com.android.dialer.common.LogUtil;
|
|
import com.android.dialer.common.concurrent.AsyncTaskExecutor;
|
|
import com.android.dialer.common.concurrent.AsyncTaskExecutors;
|
|
import com.android.dialer.util.PermissionsUtil;
|
|
import java.util.Objects;
|
|
|
|
/**
|
|
* Observes the {@link CallLog} to delete the CallLog entry for a blocked call after it is added.
|
|
* Automatically de-registers itself {@link #TIMEOUT_MS} ms after registration or if the entry is
|
|
* found and deleted.
|
|
*/
|
|
public class BlockedNumberContentObserver extends ContentObserver
|
|
implements DeleteBlockedCallTask.Listener {
|
|
|
|
/**
|
|
* The time after which a {@link BlockedNumberContentObserver} will be automatically unregistered.
|
|
*/
|
|
public static final int TIMEOUT_MS = 5000;
|
|
|
|
@NonNull private final Context context;
|
|
@NonNull private final Handler handler;
|
|
private final String number;
|
|
private final long timeAddedMillis;
|
|
private final Runnable timeoutRunnable =
|
|
new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
unregister();
|
|
}
|
|
};
|
|
|
|
private final AsyncTaskExecutor asyncTaskExecutor = AsyncTaskExecutors.createThreadPoolExecutor();
|
|
|
|
/**
|
|
* Creates the BlockedNumberContentObserver to delete the new {@link CallLog} entry from the given
|
|
* blocked number.
|
|
*
|
|
* @param number The blocked number.
|
|
* @param timeAddedMillis The time at which the call from the blocked number was placed.
|
|
*/
|
|
public BlockedNumberContentObserver(
|
|
@NonNull Context context, @NonNull Handler handler, String number, long timeAddedMillis) {
|
|
super(handler);
|
|
this.context = Objects.requireNonNull(context, "context").getApplicationContext();
|
|
this.handler = Objects.requireNonNull(handler);
|
|
this.number = number;
|
|
this.timeAddedMillis = timeAddedMillis;
|
|
}
|
|
|
|
@Override
|
|
public void onChange(boolean selfChange) {
|
|
LogUtil.i(
|
|
"BlockedNumberContentObserver.onChange",
|
|
"attempting to remove call log entry from blocked number");
|
|
asyncTaskExecutor.submit(
|
|
DeleteBlockedCallTask.IDENTIFIER,
|
|
new DeleteBlockedCallTask(context, this, number, timeAddedMillis));
|
|
}
|
|
|
|
@Override
|
|
public void onDeleteBlockedCallTaskComplete(boolean didFindEntry) {
|
|
if (didFindEntry) {
|
|
unregister();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Registers this {@link ContentObserver} to listen for changes to the {@link CallLog}. If the
|
|
* CallLog entry is not found before {@link #TIMEOUT_MS}, this ContentObserver automatically
|
|
* un-registers itself.
|
|
*/
|
|
public void register() {
|
|
LogUtil.i("BlockedNumberContentObserver.register", null);
|
|
if (PermissionsUtil.hasCallLogReadPermissions(context)
|
|
&& PermissionsUtil.hasCallLogWritePermissions(context)) {
|
|
context.getContentResolver().registerContentObserver(CallLog.CONTENT_URI, true, this);
|
|
handler.postDelayed(timeoutRunnable, TIMEOUT_MS);
|
|
} else {
|
|
LogUtil.w("BlockedNumberContentObserver.register", "no call log read/write permissions.");
|
|
}
|
|
}
|
|
|
|
private void unregister() {
|
|
LogUtil.i("BlockedNumberContentObserver.unregister", null);
|
|
handler.removeCallbacks(timeoutRunnable);
|
|
context.getContentResolver().unregisterContentObserver(this);
|
|
}
|
|
}
|