import com.google.ipc.invalidation.external.client.SystemResources; //导入依赖的package包/类
/**
 * Constructs a client.
 *
 * @param resources resources to use during execution
 * @param random a random number generator
 * @param clientType client type code
 * @param clientName application identifier for the client
 * @param config configuration for the client
 * @param applicationName name of the application using the library (for debugging/monitoring)
 * @param regManagerState marshalled registration manager state, if any
 * @param protocolHandlerState marshalled protocol handler state, if any
 * @param listener application callback
 */
private InvalidationClientCore(final SystemResources resources, Random random, int clientType,
    final byte[] clientName, ClientConfigP config, String applicationName,
    RunStateP ticlRunState,
    RegistrationManagerStateP regManagerState,
    ProtocolHandlerState protocolHandlerState,
    StatisticsState statisticsState,
    InvalidationListener listener) {
  this.resources = Preconditions.checkNotNull(resources);
  this.random = random;
  this.logger = Preconditions.checkNotNull(resources.getLogger());
  this.internalScheduler = resources.getInternalScheduler();
  this.storage = resources.getStorage();
  this.config = config;
  this.ticlState = (ticlRunState == null) ? new RunState() : new RunState(ticlRunState);
  this.smearer = new Smearer(random, this.config.getSmearPercent());
  this.applicationClientId = ApplicationClientIdP.create(clientType, new Bytes(clientName));
  this.listener = listener;
  this.statistics = (statisticsState != null)
      ? Statistics.deserializeStatistics(resources.getLogger(), statisticsState.getCounter())
      : new Statistics();
  this.registrationManager = new RegistrationManager(logger, statistics, digestFn,
      regManagerState);
  this.protocolHandler = new ProtocolHandler(config.getProtocolHandlerConfig(), resources,
      smearer, statistics, clientType, applicationName, this, protocolHandlerState);
}
 

import com.google.ipc.invalidation.external.client.SystemResources; //导入依赖的package包/类
/**
 * Registers handlers for received messages and network status changes with the network of
 * {@code resources}.
 */
private void registerWithNetwork(final SystemResources resources) {
  resources.getNetwork().setListener(new NetworkChannel.NetworkListener() {
    @Override
    public void onMessageReceived(byte[] incomingMessage) {
      InvalidationClientCore.this.handleIncomingMessage(incomingMessage);
    }
    @Override
    public void onOnlineStatusChange(boolean isOnline) {
      InvalidationClientCore.this.handleNetworkStatusChange(isOnline);
    }
    @Override
    public void onAddressChange() {
      // Send a message to the server. The header will include the new network address.
      Preconditions.checkState(internalScheduler.isRunningOnThread(), "Not on internal thread");
      sendInfoMessageToServer(false, false);
    }
  });
}
 

import com.google.ipc.invalidation.external.client.SystemResources; //导入依赖的package包/类
/** Creates a batcher from {@code marshalledState}. */
Batcher(SystemResources resources, Statistics statistics, BatcherState marshalledState) {
  this(resources, statistics);
  for (ObjectIdP registration : marshalledState.getRegistration()) {
    pendingRegistrations.put(registration, RegistrationP.OpType.REGISTER);
  }
  for (ObjectIdP unregistration : marshalledState.getUnregistration()) {
    pendingRegistrations.put(unregistration, RegistrationP.OpType.UNREGISTER);
  }
  for (InvalidationP ack : marshalledState.getAcknowledgement()) {
    pendingAckedInvalidations.add(ack);
  }
  for (RegistrationSubtree subtree : marshalledState.getRegistrationSubtree()) {
    pendingRegSubtrees.add(subtree);
  }
  pendingInitializeMessage = marshalledState.getNullableInitializeMessage();
  if (marshalledState.hasInfoMessage()) {
    pendingInfoMessage = marshalledState.getInfoMessage();
  }
}
 

import com.google.ipc.invalidation.external.client.SystemResources; //导入依赖的package包/类
/**
 * Creates an instance.
 *
 * @param config configuration for the client
 * @param resources resources to use
 * @param smearer a smearer to randomize delays
 * @param statistics track information about messages sent/received, etc
 * @param applicationName name of the application using the library (for debugging/monitoring)
 * @param listener callback for protocol events
 */
ProtocolHandler(ProtocolHandlerConfigP config, final SystemResources resources,
    Smearer smearer, Statistics statistics, int clientType, String applicationName,
    ProtocolListener listener, ProtocolHandlerState marshalledState) {
  this.logger = resources.getLogger();
  this.statistics = statistics;
  this.internalScheduler = resources.getInternalScheduler();
  this.network = resources.getNetwork();
  this.listener = listener;
  this.clientVersion = CommonProtos.newClientVersion(resources.getPlatform(), "Java",
      applicationName);
  this.clientType = clientType;
  if (marshalledState == null) {
    // If there is no marshalled state, construct a clean batcher.
    this.batcher = new Batcher(resources, statistics);
  } else {
    // Otherwise, restore the batcher from the marshalled state.
    this.batcher = new Batcher(resources, statistics, marshalledState.getBatcherState());
    this.messageId = marshalledState.getMessageId();
    this.lastKnownServerTimeMs = marshalledState.getLastKnownServerTimeMs();
    this.nextMessageSendTimeMs = marshalledState.getNextMessageSendTimeMs();
  }
  logger.info("Created protocol handler for application %s, platform %s", applicationName,
      resources.getPlatform());
}
 

import com.google.ipc.invalidation.external.client.SystemResources; //导入依赖的package包/类
/**
 * Constructs a client with state initialized from {@code marshalledState}.
 *
 * @param resources resources to use during execution
 * @param random a random number generator
 * @param clientType client type code
 * @param clientName application identifier for the client
 * @param config configuration for the client
 * @param applicationName name of the application using the library (for debugging/monitoring)
 * @param listener application callback
 */
public InvalidationClientCore(final SystemResources resources, Random random, int clientType,
    final byte[] clientName, ClientConfigP config, String applicationName,
    InvalidationClientState marshalledState, InvalidationListener listener) {
  this(resources, random, clientType, clientName, config, applicationName,
      marshalledState.getRunState(), marshalledState.getRegistrationManagerState(),
      marshalledState.getProtocolHandlerState(), marshalledState.getStatisticsState(), listener);
  // Unmarshall.
  if (marshalledState.hasClientToken()) {
    clientToken = marshalledState.getClientToken();
  }
  if (marshalledState.hasNonce()) {
    nonce = marshalledState.getNonce();
  }
  this.shouldSendRegistrations = marshalledState.getShouldSendRegistrations();
  this.lastMessageSendTimeMs = marshalledState.getLastMessageSendTimeMs();
  this.isOnline = marshalledState.getIsOnline();
  createSchedulingTasks(marshalledState);

  // We register with the network after unmarshalling our isOnline value. This is because when
  // we register with the network, it may give us a new value for isOnline. If we unmarshalled
  // after registering, then we would clobber the new value with the old marshalled value, which
  // is wrong.
  registerWithNetwork(resources);
  logger.info("Created client: %s", this);
}
 

import com.google.ipc.invalidation.external.client.SystemResources; //导入依赖的package包/类
/**
 * Registers handlers for received messages and network status changes with the network of
 * {@code resources}.
 */
private void registerWithNetwork(final SystemResources resources) {
  resources.getNetwork().setListener(new NetworkChannel.NetworkListener() {
    @Override
    public void onMessageReceived(byte[] incomingMessage) {
      final String name = "handleIncomingMessage";
      InvalidationClientCore.this.handleIncomingMessage(incomingMessage);
    }
    @Override
    public void onOnlineStatusChange(boolean isOnline) {
      InvalidationClientCore.this.handleNetworkStatusChange(isOnline);
    }
    @Override
    public void onAddressChange() {
      // Send a message to the server. The header will include the new network address.
      Preconditions.checkState(internalScheduler.isRunningOnThread(), "Not on internal thread");
      sendInfoMessageToServer(false, false);
    }
  });
}
 

import com.google.ipc.invalidation.external.client.SystemResources; //导入依赖的package包/类
/**
 * A utility function to run an async runnable with exponential backoff after failures.
 * @param runnable the asynchronous runnable.
 * @param scheduler used to schedule retries.
 * @param backOffGenerator a backoff generator that returns how to long to wait between retries.
 *     The client must pass a new instance or reset the backoff generator before calling this
 *     method.
 */

static void retryUntilSuccessWithBackoff(final SystemResources.Scheduler scheduler,
    final ExponentialBackoffDelayGenerator backOffGenerator, final AsyncRunnable runnable) {
  logger.fine("Running %s", runnable);
  runnable.run(new CompletionCallback() {
      @Override
      public void success() {
        logger.fine("%s succeeded", runnable);
      }

      @Override
      public void failure() {
        int nextDelay = backOffGenerator.getNextDelay();
        logger.fine("%s failed, retrying after %s ms", nextDelay);
        scheduler.schedule(nextDelay, new Runnable() {
          @Override
          public void run() {
            retryUntilSuccessWithBackoff(scheduler, backOffGenerator, runnable);
          }
        });
      }
  });
}
 

import com.google.ipc.invalidation.external.client.SystemResources; //导入依赖的package包/类
@Override
public void setSystemResources(SystemResources resources) {
  this.resources = resources;

  // Prefetch the auth sub token.  Since this might require an HTTP round trip, we do this
  // as soon as the resources are available.
  // TODO: Find a better place to fetch the auth token; this method
  // doesn't sound like one that should be doing work.
  retryUntilSuccessWithBackoff(resources.getInternalScheduler(),
      new ExponentialBackoffDelayGenerator(
          new Random(), INITIAL_AUTH_TOKEN_RETRY_DELAY_MS, MAX_AUTH_TOKEN_RETRY_FACTOR),
      new AsyncRunnable() {
        @Override
        public void run(CompletionCallback callback) {
          requestAuthToken(callback);
        }
      });
}
 

import com.google.ipc.invalidation.external.client.SystemResources; //导入依赖的package包/类
/**
 * Creates a new InvalidationClient instance that the proxy will delegate requests to and listen
 * for events from.
 */
// Overridden by tests to inject mock clients or for listener interception

InvalidationClient createClient(SystemResources resources, int clientType, byte[] clientName,
    String applicationName, InvalidationListener listener, ClientConfigP config) {
  // We always use C2DM, so set the channel-supports-offline-delivery bit on our config.
  final ClientConfigP.Builder configBuilder;
  if (config == null) {
    configBuilder = InvalidationClientCore.createConfig();
  } else {
    configBuilder = ClientConfigP.newBuilder(config);
  }
  configBuilder.setChannelSupportsOfflineDelivery(true);
  config = configBuilder.build();
  Random random = new Random(resources.getInternalScheduler().getCurrentTimeMs());
  return new InvalidationClientImpl(resources, random, clientType, clientName, config,
      applicationName, listener);
}
 

import com.google.ipc.invalidation.external.client.SystemResources; //导入依赖的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.ipc.invalidation.external.client.SystemResources; //导入依赖的package包/类
/**
 * Creates an instance with state restored from {@code marshalledState}. Other parameters are as
 * in {@link InvalidationClientCore}.
 */
AndroidInvalidationClientImpl(Context context, SystemResources resources, Random random,
    AndroidTiclState marshalledState) {
  super(resources,
      random,
      marshalledState.getMetadata().getClientType(),
      marshalledState.getMetadata().getClientName().getByteArray(),
      marshalledState.getMetadata().getClientConfig(),
      getApplicationName(context),
      marshalledState.getTiclState(),
      new IntentForwardingListener(context, resources.getLogger()));
  this.schedulingId = marshalledState.getMetadata().getTiclId();
  initializeSchedulerWithRecurringTasks();
}
 

import com.google.ipc.invalidation.external.client.SystemResources; //导入依赖的package包/类
/**
 * Restores the Ticl from persistent storage if it exists. Otherwise, returns {@code null}.
 * @param context Android system context
 * @param resources resources to use for the Ticl
 */
static AndroidInvalidationClientImpl restoreTicl(Context context,
    SystemResources resources) {
  AndroidTiclState state = readTiclState(context, resources.getLogger());
  if (state == null) {
    return null;
  }
  AndroidInvalidationClientImpl ticl = new AndroidInvalidationClientImpl(context, resources,
      random, state);
  initScheduler(resources, ticl, state.getScheduledTask());
  AndroidInternalScheduler scheduler =
      (AndroidInternalScheduler) resources.getInternalScheduler();
  scheduler.handleImplicitSchedulerEvent();
  return ticl;
}
 

import com.google.ipc.invalidation.external.client.SystemResources; //导入依赖的package包/类
/** Creates a new Ticl. Persistent storage must not exist. */
static void createTicl(Context context, SystemResources resources, int clientType,
    byte[] clientName, ClientConfigP config, boolean skipStartForTest) {
  Preconditions.checkState(!doesStateFileExist(context), "Ticl already exists");
  AndroidInvalidationClientImpl ticl = new AndroidInvalidationClientImpl(context, resources,
      random, clientType, clientName, config);
  if (!skipStartForTest) {
    // Ticls are started when created unless this should be skipped for tests; we allow tests
    // to skip starting Ticls because many integration tests assume that Ticls will not be
    // started when created.
    initScheduler(resources, ticl, new ArrayList<ScheduledTask>(0));
    ticl.start();
  }
  saveTicl(context, resources.getLogger(), ticl);
}
 

import com.google.ipc.invalidation.external.client.SystemResources; //导入依赖的package包/类
/**
 * Sets the scheduling id on the scheduler in {@code resources} to {@code ticl.getSchedulingId()}
 * and seeds the scheduler with scheduled tasks that had been persisted.
 */
private static void initScheduler(SystemResources resources,
    AndroidInvalidationClientImpl ticl, List<ScheduledTask> scheduledTasks) {
  AndroidInternalScheduler scheduler =
      (AndroidInternalScheduler) resources.getInternalScheduler();
  scheduler.init(ticl.getSchedulingId(), scheduledTasks);
}
 

import com.google.ipc.invalidation.external.client.SystemResources; //导入依赖的package包/类
/** Creates a new instance with default state. */
BatchingTask(ProtocolHandler protocolHandler, SystemResources resources, Smearer smearer,
    int batchingDelayMs) {
  super(TASK_NAME, resources.getInternalScheduler(), resources.getLogger(), smearer, null,
      batchingDelayMs, NO_DELAY);
  this.protocolHandler = protocolHandler;
}
 

import com.google.ipc.invalidation.external.client.SystemResources; //导入依赖的package包/类
public InvalidationClientImpl(final SystemResources resources, Random random, int clientType,
    final byte[] clientName, ClientConfigP config, String applicationName,
    InvalidationListener listener) {
  super(
      // We will make Storage a SafeStorage after the constructor call. It's not possible to
      // construct a new resources around the existing components and pass that to super(...)
      // because then subsequent calls on the first resources object (e.g., start) would not
      // affect the new resources object that the Ticl would be using.
      resources,

      // Pass basic parameters through unmodified.
      random, clientType, clientName, config, applicationName,

      // Wrap the listener in a CheckingInvalidationListener to enforce appropriate threading.
      new CheckingInvalidationListener(listener,
          resources.getInternalScheduler(), resources.getListenerScheduler(),
          resources.getLogger())
  ); // End super.

  // Make Storage safe.
  this.storage = new SafeStorage(resources.getStorage());
  this.storage.setSystemResources(resources);

  // CheckingInvalidationListener needs the statistics object created by our super() call, so
  // we can't provide it at construction-time (since it hasn't been created yet).
  ((CheckingInvalidationListener) this.listener).setStatistics(statistics);

}
 

import com.google.ipc.invalidation.external.client.SystemResources; //导入依赖的package包/类
/**
 * Creates an instance with state restored from {@code marshalledState}. Other parameters are as
 * in {@link InvalidationClientCore}.
 */
AndroidInvalidationClientImpl(Context context, SystemResources resources, Random random,
    AndroidTiclState marshalledState) {
  super(resources,
      random,
      marshalledState.getMetadata().getClientType(),
      marshalledState.getMetadata().getClientName().toByteArray(),
      marshalledState.getMetadata().getClientConfig(),
      getApplicationName(context),
      marshalledState.getTiclState(),
      new IntentForwardingListener(context, resources.getLogger()));
  this.schedulingId = marshalledState.getMetadata().getTiclId();
  initializeSchedulerWithRecurringTasks();
}
 

import com.google.ipc.invalidation.external.client.SystemResources; //导入依赖的package包/类
/**
 * Restores the Ticl from persistent storage if it exists. Otherwise, returns {@code null}.
 * @param context Android system context
 * @param resources resources to use for the Ticl
 */
static AndroidInvalidationClientImpl restoreTicl(Context context,
    SystemResources resources) {
  AndroidTiclState state = readTiclState(context, resources.getLogger());
  if (state == null) {
    return null;
  }
  AndroidInvalidationClientImpl ticl = new AndroidInvalidationClientImpl(context, resources,
      random, state);
  setSchedulerId(resources, ticl);
  return ticl;
}
 

import com.google.ipc.invalidation.external.client.SystemResources; //导入依赖的package包/类
/** Creates a new Ticl. Persistent stroage must not exist. */
static void createTicl(Context context, SystemResources resources, int clientType,
    byte[] clientName, ClientConfigP config, boolean skipStartForTest) {
  Preconditions.checkState(!doesStateFileExist(context), "Ticl already exists");
  AndroidInvalidationClientImpl ticl = new AndroidInvalidationClientImpl(context, resources,
      random, clientType, clientName, config);
  if (!skipStartForTest) {
    // Ticls are started when created unless this should be skipped for tests; we allow tests
    // to skip starting Ticls because many integration tests assume that Ticls will not be
    // started when created.
    setSchedulerId(resources, ticl);
    ticl.start();
  }
  saveTicl(context, resources.getLogger(), ticl);
}
 

import com.google.ipc.invalidation.external.client.SystemResources; //导入依赖的package包/类
/**
 * Sets the scheduling id on the scheduler in {@code resources} to {@code ticl.getSchedulingId()}.
 */
private static void setSchedulerId(SystemResources resources,
    AndroidInvalidationClientImpl ticl) {
  AndroidInternalScheduler scheduler =
      (AndroidInternalScheduler) resources.getInternalScheduler();
  scheduler.setTiclId(ticl.getSchedulingId());
}