package android.location;
import android.annotation.NonNull;
import android.content.Context;
import android.os.Handler;
import android.os.RemoteException;
import android.util.Log;
import com.android.internal.util.Preconditions;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
abstract class LocalListenerHelper<TListener> {
private final HashMap<TListener, Handler> mListeners = new HashMap<>();
private final String mTag;
private final Context mContext;
protected LocalListenerHelper(Context context, String name) {
Preconditions.checkNotNull(name);
mContext = context;
mTag = name;
}
public boolean add(@NonNull TListener listener, Handler handler) {
Preconditions.checkNotNull(listener);
synchronized (mListeners) {
if (mListeners.isEmpty()) {
boolean registeredWithService;
try {
registeredWithService = registerWithServer();
} catch (RemoteException e) {
Log.e(mTag, "Error handling first listener.", e);
return false;
}
if (!registeredWithService) {
Log.e(mTag, "Unable to register listener transport.");
return false;
}
}
if (mListeners.containsKey(listener)) {
return true;
}
mListeners.put(listener, handler);
return true;
}
}
public void remove(@NonNull TListener listener) {
Preconditions.checkNotNull(listener);
synchronized (mListeners) {
boolean removed = mListeners.containsKey(listener);
mListeners.remove(listener);
boolean isLastRemoved = removed && mListeners.isEmpty();
if (isLastRemoved) {
try {
unregisterFromServer();
} catch (RemoteException e) {
Log.v(mTag, "Error handling last listener removal", e);
}
}
}
}
protected abstract boolean registerWithServer() throws RemoteException;
protected abstract void unregisterFromServer() throws RemoteException;
protected interface ListenerOperation<TListener> {
void execute(TListener listener) throws RemoteException;
}
protected Context getContext() {
return mContext;
}
private void executeOperation(ListenerOperation<TListener> operation, TListener listener) {
try {
operation.execute(listener);
} catch (RemoteException e) {
Log.e(mTag, "Error in monitored listener.", e);
}
}
protected void foreach(final ListenerOperation<TListener> operation) {
Collection<Map.Entry<TListener, Handler>> listeners;
synchronized (mListeners) {
listeners = new ArrayList<>(mListeners.entrySet());
}
for (final Map.Entry<TListener, Handler> listener : listeners) {
if (listener.getValue() == null) {
executeOperation(operation, listener.getKey());
} else {
listener.getValue().post(new Runnable() {
@Override
public void run() {
executeOperation(operation, listener.getKey());
}
});
}
}
}
}