import com.google.protos.ipc.invalidation.ClientProtocol.ObjectIdP; //导入依赖的package包/类
/**
 * Appends a description of the given {@code registration} downcall to the given {@code builder}.
 */
public static TextBuilder toCompactString(TextBuilder builder,
    RegistrationDowncall registration) {
  if (registration == null) {
    return builder;
  }
  List<ObjectIdP> objects;
  if (registration.getRegistrationsCount() > 0) {
    builder.append("register(");
    objects = registration.getRegistrationsList();
  } else {
    builder.append("unregister(");
    objects = registration.getUnregistrationsList();
  }
  return CommonProtoStrings2.toCompactStringForObjectIds(builder, objects).append(")");
}
 

import com.google.protos.ipc.invalidation.ClientProtocol.ObjectIdP; //导入依赖的package包/类
/**
 * Informs the manager of a new registration state summary from the server.
 * Returns a possibly-empty map of <object-id, reg-op-type>. For each entry in the map,
 * the caller should make an inform-registration-status upcall on the listener.
 */
Set<ProtoWrapper<RegistrationP>> informServerRegistrationSummary(
    RegistrationSummary regSummary) {
  if (regSummary != null) {
    this.lastKnownServerSummary = ProtoWrapper.of(regSummary);
  }
  if (isStateInSyncWithServer()) {
    // If we are now in sync with the server, then the caller should make inform-reg-status
    // upcalls for all operations that we had pending, if any; they are also no longer pending.
    Set<ProtoWrapper<RegistrationP>> upcallsToMake =
        new HashSet<ProtoWrapper<RegistrationP>>(pendingOperations.size());
    for (Map.Entry<ProtoWrapper<ObjectIdP>, RegistrationP.OpType> entry :
        pendingOperations.entrySet()) {
      ObjectIdP objectId = entry.getKey().getProto();
      boolean isReg = entry.getValue() == OpType.REGISTER;
      upcallsToMake.add(ProtoWrapper.of(CommonProtos2.newRegistrationP(objectId, isReg)));
    }
    pendingOperations.clear();
    return upcallsToMake;
  } else {
    // If we are not in sync with the server, then the caller should make no upcalls.
    return Collections.emptySet();
  }
}
 

import com.google.protos.ipc.invalidation.ClientProtocol.ObjectIdP; //导入依赖的package包/类
/** Initializes state from proto. */
AndroidListenerState(int initialMaxDelayMs, int maxDelayFactor,
    AndroidListenerProtocol.AndroidListenerState state) {
  desiredRegistrations = new HashSet<ObjectId>();
  for (ObjectIdP objectIdProto : state.getRegistrationList()) {
    desiredRegistrations.add(ProtoConverter.convertFromObjectIdProto(objectIdProto));
  }
  for (RetryRegistrationState retryState : state.getRetryRegistrationStateList()) {
    ObjectId objectId = ProtoConverter.convertFromObjectIdProto(retryState.getObjectId());
    delayGenerators.put(objectId, new TiclExponentialBackoffDelayGenerator(random,
        initialMaxDelayMs, maxDelayFactor, retryState.getExponentialBackoffState()));
  }
  clientId = state.getClientId();
  requestCodeSeqNum = state.getRequestCodeSeqNum();
  isDirty = false;
  this.initialMaxDelayMs = initialMaxDelayMs;
  this.maxDelayFactor = maxDelayFactor;
}
 

import com.google.protos.ipc.invalidation.ClientProtocol.ObjectIdP; //导入依赖的package包/类
/** See spec in implementation notes. */
public static TextBuilder toCompactStringForObjectIds(TextBuilder builder,
    Collection<ObjectIdP> objectIds) {
  if (objectIds == null) {
    return builder;
  }
  boolean first = true;
  builder.append("ObjectIds: ");
  for (ObjectIdP objectId : objectIds) {
    if (!first) {
      builder.append(", ");
    }
    toCompactString(builder, objectId);
    first = false;
  }
  return builder;
}
 

import com.google.protos.ipc.invalidation.ClientProtocol.ObjectIdP; //导入依赖的package包/类
/** Creates a batcher from {@code marshalledState}. */
Batcher(SystemResources resources, Statistics statistics, BatcherState marshalledState) {
  this(resources, statistics);
  for (ObjectIdP registration : marshalledState.getRegistrationList()) {
    pendingRegistrations.put(ProtoWrapper.of(registration), RegistrationP.OpType.REGISTER);
  }
  for (ObjectIdP unregistration : marshalledState.getUnregistrationList()) {
    pendingRegistrations.put(ProtoWrapper.of(unregistration), RegistrationP.OpType.UNREGISTER);
  }
  for (InvalidationP ack : marshalledState.getAcknowledgementList()) {
    pendingAckedInvalidations.add(ProtoWrapper.of(ack));
  }
  for (RegistrationSubtree subtree : marshalledState.getRegistrationSubtreeList()) {
    pendingRegSubtrees.add(ProtoWrapper.of(subtree));
  }
  if (marshalledState.hasInitializeMessage()) {
    pendingInitializeMessage = marshalledState.getInitializeMessage();
  }
  if (marshalledState.hasInfoMessage()) {
    pendingInfoMessage = marshalledState.getInfoMessage();
  }
}
 

import com.google.protos.ipc.invalidation.ClientProtocol.ObjectIdP; //导入依赖的package包/类
/**
 * Converts an object id {@code objectId} to the corresponding protocol buffer
 * and returns it.
 */

public static ObjectIdP convertToObjectIdProto(ObjectId objectId) {
  Preconditions.checkNotNull(objectId);
  return CommonProtos2.newObjectIdP(objectId.getSource(),
      ByteString.copyFrom(objectId.getName()));
}
 

import com.google.protos.ipc.invalidation.ClientProtocol.ObjectIdP; //导入依赖的package包/类
/**
 * Returns a list of {@link ObjectIdP} by converting each element of {@code objectIds} to
 * an {@code ObjectIdP}.
 */
public static List<ObjectIdP> convertToObjectIdProtoList(Collection<ObjectId> objectIds) {
  List<ObjectIdP> objectIdPs = new ArrayList<ObjectIdP>(objectIds.size());
  for (ObjectId objectId : objectIds) {
    objectIdPs.add(ProtoConverter.convertToObjectIdProto(objectId));
  }
  return objectIdPs;
}
 

import com.google.protos.ipc.invalidation.ClientProtocol.ObjectIdP; //导入依赖的package包/类
/**
 * Returns a list of {@link ObjectId} by converting each element of {@code oidPs} to
 * an {@code ObjectId}.
 */
public static List<ObjectId> convertToObjectIdList(List<ObjectIdP> oidPs) {
  List<ObjectId> objects = new ArrayList<ObjectId>(oidPs.size());
  for (ObjectIdP oidP : oidPs) {
    objects.add(ObjectId.newInstance(oidP.getSource(), oidP.getName().toByteArray()));
  }
  return objects;
}
 

import com.google.protos.ipc.invalidation.ClientProtocol.ObjectIdP; //导入依赖的package包/类
/**
 * Converts an invalidation {@code invalidation} to the corresponding protocol
 * buffer and returns it.
 */
public static InvalidationP convertToInvalidationProto(Invalidation invalidation) {
  Preconditions.checkNotNull(invalidation);
  ObjectIdP objectId = convertToObjectIdProto(invalidation.getObjectId());

  // Invalidations clients do not know about trickle restarts. Every invalidation is allowed
  // to suppress earlier invalidations and acks implicitly acknowledge all previous
  // invalidations. Therefore the correct semanantics are provided by setting isTrickleRestart to
  // true.
  return CommonProtos2.newInvalidationP(objectId, invalidation.getVersion(),
      TrickleState.fromBoolean(invalidation.getIsTrickleRestartForInternalUse()),
      invalidation.getPayload() == null ? null : ByteString.copyFrom(invalidation.getPayload()));
}
 

import com.google.protos.ipc.invalidation.ClientProtocol.ObjectIdP; //导入依赖的package包/类
public static InvalidationP newInvalidationPForUnknownVersion(ObjectIdP oid,
    long sequenceNumber) {
  return InvalidationP.newBuilder()
      .setObjectId(oid)
      .setIsKnownVersion(false)
      .setIsTrickleRestart(true)
      .setVersion(sequenceNumber)
      .build();
}
 

import com.google.protos.ipc.invalidation.ClientProtocol.ObjectIdP; //导入依赖的package包/类
public static Intent newInvalidateUnknownIntent(ObjectIdP object, AckHandleP ackHandle) {
  Intent intent = new Intent();
  InvalidateUpcall invUpcall = InvalidateUpcall.newBuilder()
      .setAckHandle(ackHandle.toByteString())
      .setInvalidateUnknown(object).build();
  intent.putExtra(LISTENER_UPCALL_KEY,
      newBuilder().setInvalidate(invUpcall).build().toByteArray());
  return intent;
}
 

import com.google.protos.ipc.invalidation.ClientProtocol.ObjectIdP; //导入依赖的package包/类
public static Intent newRegistrationStatusIntent(ObjectIdP object, boolean isRegistered) {
  Intent intent = new Intent();
  RegistrationStatusUpcall regUpcall = RegistrationStatusUpcall.newBuilder()
        .setObjectId(object)
        .setIsRegistered(isRegistered).build();
  intent.putExtra(LISTENER_UPCALL_KEY,
      newBuilder().setRegistrationStatus(regUpcall).build().toByteArray());
  return intent;
}
 

import com.google.protos.ipc.invalidation.ClientProtocol.ObjectIdP; //导入依赖的package包/类
public static Intent newRegistrationFailureIntent(ObjectIdP object, boolean isTransient,
    String message) {
  Intent intent = new Intent();
  RegistrationFailureUpcall regUpcall = RegistrationFailureUpcall.newBuilder()
        .setObjectId(object)
        .setTransient(isTransient)
        .setMessage(message).build();
  intent.putExtra(LISTENER_UPCALL_KEY,
      newBuilder().setRegistrationFailure(regUpcall).build().toByteArray());
  return intent;
}
 

import com.google.protos.ipc.invalidation.ClientProtocol.ObjectIdP; //导入依赖的package包/类
/**
 * Returns a copy of the registration manager's state
 * <p>
 * Direct test code MUST not call this method on a random thread. It must be called on the
 * InvalidationClientImpl's internal thread.
 */

RegistrationManagerState getRegistrationManagerStateCopyForTest(DigestFunction digestFunction) {
  List<ObjectIdP> registeredObjects = new ArrayList<ObjectIdP>();
  for (ObjectIdP oid : desiredRegistrations.getElements(EMPTY_PREFIX, 0)) {
    registeredObjects.add(oid);
  }
  return new RegistrationManagerState(
      RegistrationSummary.newBuilder(getRegistrationSummary()).build(),
      RegistrationSummary.newBuilder(lastKnownServerSummary.getProto()).build(),
      registeredObjects);
}
 

import com.google.protos.ipc.invalidation.ClientProtocol.ObjectIdP; //导入依赖的package包/类
/** Perform registration/unregistation for all objects in {@code objectIds}. */
Collection<ObjectIdP> performOperations(Collection<ObjectIdP> objectIds,
    RegistrationP.OpType regOpType) {
  // Record that we have pending operations on the objects.
  for (ObjectIdP objectId : objectIds) {
    pendingOperations.put(ProtoWrapper.of(objectId), regOpType);
  }
  // Update the digest appropriately.
  if (regOpType == RegistrationP.OpType.REGISTER) {
    return desiredRegistrations.add(objectIds);
  } else {
    return desiredRegistrations.remove(objectIds);
  }
}
 

import com.google.protos.ipc.invalidation.ClientProtocol.ObjectIdP; //导入依赖的package包/类
/**
 * Removes all desired registrations and pending operations. Returns all object ids
 * that were affected.
 * <p>
 * REQUIRES: the caller issue a permanent failure upcall to the listener for all returned object
 * ids.
 */
Collection<ProtoWrapper<ObjectIdP>> removeRegisteredObjects() {
  int numObjects = desiredRegistrations.size() + pendingOperations.size();
  Set<ProtoWrapper<ObjectIdP>> failureCalls = new HashSet<ProtoWrapper<ObjectIdP>>(numObjects);
  for (ObjectIdP objectId : desiredRegistrations.removeAll()) {
    failureCalls.add(ProtoWrapper.of(objectId));
  }
  failureCalls.addAll(pendingOperations.keySet());
  pendingOperations.clear();
  return failureCalls;
}
 

import com.google.protos.ipc.invalidation.ClientProtocol.ObjectIdP; //导入依赖的package包/类
@Override
public RegistrationManagerStateP marshal() {
  RegistrationManagerStateP.Builder builder = RegistrationManagerStateP.newBuilder();
  builder.setLastKnownServerSummary(lastKnownServerSummary.getProto());
  builder.addAllRegistrations(desiredRegistrations.getElements(EMPTY_PREFIX, 0));
  for (Map.Entry<ProtoWrapper<ObjectIdP>, RegistrationP.OpType> pendingOp :
      pendingOperations.entrySet()) {
    ObjectIdP objectId = pendingOp.getKey().getProto();
    boolean isReg = pendingOp.getValue() == OpType.REGISTER;
    builder.addPendingOperations(CommonProtos2.newRegistrationP(objectId, isReg));
  }
  return builder.build();
}
 

import com.google.protos.ipc.invalidation.ClientProtocol.ObjectIdP; //导入依赖的package包/类
@Override
public boolean add(ObjectIdP oid) {
  if (registrations.put(ObjectIdDigestUtils.getDigest(oid, digestFunction), oid) == null) {
    recomputeDigest();
    return true;
  }
  return false;
}
 

import com.google.protos.ipc.invalidation.ClientProtocol.ObjectIdP; //导入依赖的package包/类
@Override
public boolean remove(ObjectIdP oid) {
  if (registrations.remove(ObjectIdDigestUtils.getDigest(oid, digestFunction)) != null) {
    recomputeDigest();
    return true;
  }
  return false;
}
 

import com.google.protos.ipc.invalidation.ClientProtocol.ObjectIdP; //导入依赖的package包/类
@Override
public Collection<ObjectIdP> removeAll() {
  Collection<ObjectIdP> result = new ArrayList<ObjectIdP>(registrations.values());
  registrations.clear();
  recomputeDigest();
  return result;
}