import com.google.ipc.invalidation.external.client.types.Status; //导入依赖的package包/类
/** Reads the Ticl state from persistent storage (if any) and calls {@code startInternal}. */
private void scheduleStartAfterReadingStateBlob() {
  storage.readKey(CLIENT_TOKEN_KEY, new Callback<SimplePair<Status, byte[]>>() {
    @Override
    public void accept(final SimplePair<Status, byte[]> readResult) {
      Preconditions.checkState(internalScheduler.isRunningOnThread(), "Not on internal thread");
      final byte[] serializedState = readResult.getFirst().isSuccess() ?
          readResult.getSecond() : null;
      // Call start now.
      if (!readResult.getFirst().isSuccess()) {
        statistics.recordError(ClientErrorType.PERSISTENT_READ_FAILURE);
        logger.warning("Could not read state blob: %s", readResult.getFirst().getMessage());
      }
      startInternal(serializedState);
    }
  });
}
 

import com.google.ipc.invalidation.external.client.types.Status; //导入依赖的package包/类
@Override
public void writeKey(final String key, final byte[] value, final Callback<Status> callback) {
  // Need to schedule immediately because C++ locks aren't reentrant, and
  // C++ locking code assumes that this call will not return directly.

  // Schedule the write even if the resources are started since the
  // scheduler will prevent it from running in case the resources have been
  // stopped.
  scheduler.schedule(Scheduler.NO_DELAY,
      new NamedRunnable("MemoryStorage.writeKey") {
    @Override
    public void run() {
      ticlPersistentState.put(key, value);
      callback.accept(Status.newInstance(Status.Code.SUCCESS, ""));
    }
  });
}
 

import com.google.ipc.invalidation.external.client.types.Status; //导入依赖的package包/类
@Override
public void readKey(final String key, final Callback<SimplePair<Status, byte[]>> done) {
  scheduler.schedule(Scheduler.NO_DELAY,
      new NamedRunnable("MemoryStorage.readKey") {
    @Override
    public void run() {
      byte[] value = TypedUtil.mapGet(ticlPersistentState, key);
      final SimplePair<Status, byte[]> result;
      if (value != null) {
        result = SimplePair.of(Status.newInstance(Status.Code.SUCCESS, ""), value);
      } else {
        String error = "No value present in map for " + key;
        result = SimplePair.of(Status.newInstance(Status.Code.PERMANENT_FAILURE, error), null);
      }
      done.accept(result);
    }
  });
}
 

import com.google.ipc.invalidation.external.client.types.Status; //导入依赖的package包/类
@Override
public void readKey(final String key, final Callback<SimplePair<Status, byte[]>> done) {
  scheduler.execute(new NamedRunnable("AndroidStorage.readKey") {
    @Override
    public void run() {
        byte [] value = properties.get(key);
        if (value != null) {
          done.accept(SimplePair.of(SUCCESS, value));
        } else {
          Status status =
              Status.newInstance(Status.Code.PERMANENT_FAILURE, "No value in map for " + key);
          done.accept(SimplePair.of(status, (byte []) null));
        }
    }
  });
}
 

import com.google.ipc.invalidation.external.client.types.Status; //导入依赖的package包/类
@Override
public void readAllKeys(Callback<SimplePair<Status, String>> keyCallback) {
  // If the state file exists, supply the CLIENT_TOKEN_KEY as a present key.
  if (context.getFileStreamPath(STATE_FILENAME).exists()) {
    Status status = Status.newInstance(Status.Code.SUCCESS, "");
    keyCallback.accept(SimplePair.of(status, InvalidationClientCore.CLIENT_TOKEN_KEY));
  }
  keyCallback.accept(null);
}
 

import com.google.ipc.invalidation.external.client.types.Status; //导入依赖的package包/类
@Override
public void writeKey(String key, byte[] value, final Callback<Status> done) {
  delegate.writeKey(key, value, new Callback<Status>() {
    @Override
    public void accept(final Status status) {
      scheduler.schedule(NO_DELAY, new NamedRunnable("SafeStorage.writeKey") {
        @Override
        public void run() {
          done.accept(status);
        }
      });
    }
  });
}
 

import com.google.ipc.invalidation.external.client.types.Status; //导入依赖的package包/类
@Override
public void readKey(String key, final Callback<SimplePair<Status, byte[]>> done) {
  delegate.readKey(key, new Callback<SimplePair<Status, byte[]>>() {
    @Override
    public void accept(final SimplePair<Status, byte[]> result) {
      scheduler.schedule(NO_DELAY, new NamedRunnable("SafeStorage.readKey") {
        @Override
        public void run() {
          done.accept(result);
        }
      });
    }
  });
}
 

import com.google.ipc.invalidation.external.client.types.Status; //导入依赖的package包/类
@Override
public void readAllKeys(final Callback<SimplePair<Status, String>> keyCallback) {
  delegate.readAllKeys(new Callback<SimplePair<Status, String>>() {
    @Override
    public void accept(final SimplePair<Status, String> keyResult) {
      scheduler.schedule(NO_DELAY, new NamedRunnable("SafeStorage.readAllKeys") {
        @Override
        public void run() {
          keyCallback.accept(keyResult);
        }
      });
    }
  });
}
 

import com.google.ipc.invalidation.external.client.types.Status; //导入依赖的package包/类
@Override
public void readAllKeys(final Callback<SimplePair<Status, String>> done) {
  scheduler.schedule(Scheduler.NO_DELAY,
      new NamedRunnable("MemoryStorage.readAllKeys") {
    @Override
    public void run() {
      Status successStatus = Status.newInstance(Status.Code.SUCCESS, "");
      for (String key : ticlPersistentState.keySet()) {
        done.accept(SimplePair.of(successStatus, key));
      }
      done.accept(null);
    }
  });
}
 

import com.google.ipc.invalidation.external.client.types.Status; //导入依赖的package包/类
@Override
public void readAllKeys(final Callback<SimplePair<Status, String>> keyCallback) {
  scheduler.execute(new NamedRunnable("AndroidStorage.readAllKeys") {
    @Override
    public void run() {
      for (String key : properties.keySet()) {
        keyCallback.accept(SimplePair.of(SUCCESS, key));
      }
    }
  });
}
 

import com.google.ipc.invalidation.external.client.types.Status; //导入依赖的package包/类
@Override
public void writeKey(final String key, final byte[] value, final Callback<Status> done) {
  scheduler.execute(new NamedRunnable("AndroidStorage.writeKey") {
    @Override
    public void run() {
      properties.put(key, value);
      store();
      done.accept(SUCCESS);
    }
  });
}
 

import com.google.ipc.invalidation.external.client.types.Status; //导入依赖的package包/类
/**
 * Handles a {@code message} for a {@code ticl}. If the {@code ticl} is started, delivers the
 * message. If the {@code ticl} is not started, drops the message and clears the last message send
 * time in the Ticl persistent storage so that the Ticl will send a heartbeat the next time it
 * starts.
 */
private void handleServerMessage(boolean isTiclStarted, byte[] message) {
  if (isTiclStarted) {
    // Normal case -- message for a started Ticl. Deliver the message.
    resources.getNetworkListener().onMessageReceived(message);
    return;
  }

  // Even if the client is stopped, attempt to send invalidations if the client is configured to
  // receive them.
  maybeSendBackgroundInvalidationIntent(message);

  // The Ticl isn't started. Rewrite persistent storage so that the last-send-time is a long
  // time ago. The next time the Ticl starts, it will send a message to the data center, which
  // ensures that it will be marked online and that the dropped message (or an equivalent) will
  // be delivered.
  // Android storage implementations are required to execute callbacks inline, so this code
  // all executes synchronously.
  resources.getLogger().fine("Message for unstarted Ticl; rewrite state");
  resources.getStorage().readKey(InvalidationClientCore.CLIENT_TOKEN_KEY,
      new Callback<SimplePair<Status, byte[]>>() {
    @Override
    public void accept(SimplePair<Status, byte[]> result) {
      byte[] stateBytes = result.second;
      if (stateBytes == null) {
        resources.getLogger().info("No persistent state found for client; not rewriting");
        return;
      }
      // Create new state identical to the old state except with a cleared
      // lastMessageSendTimeMs.
      PersistentTiclState state = PersistenceUtils.deserializeState(
          resources.getLogger(), stateBytes, digestFn);
      if (state == null) {
        resources.getLogger().warning("Ignoring invalid Ticl state: %s",
            Bytes.toLazyCompactString(stateBytes));
        return;
      }
      PersistentTiclState.Builder stateBuilder = state.toBuilder();
      stateBuilder.lastMessageSendTimeMs = 0L;
      state = stateBuilder.build();

      // Serialize the new state and write it to storage.
      byte[] newClientState = PersistenceUtils.serializeState(state, digestFn);
      resources.getStorage().writeKey(InvalidationClientCore.CLIENT_TOKEN_KEY, newClientState,
          new Callback<Status>() {
            @Override
            public void accept(Status status) {
              if (status.getCode() != Status.Code.SUCCESS) {
                resources.getLogger().warning(
                    "Failed saving rewritten persistent state to storage");
              }
            }
      });
    }
  });
}
 

import com.google.ipc.invalidation.external.client.types.Status; //导入依赖的package包/类
@Override
public boolean runTask() {
  if (clientToken == null) {
    // We cannot write without a token. We must do this check before creating the
    // PersistentTiclState because newPersistentTiclState cannot handle null tokens.
    return false;
  }

  // Compute the state that we will write if we decide to go ahead with the write.
  final PersistentTiclState state =
      PersistentTiclState.create(clientToken, lastMessageSendTimeMs);
  byte[] serializedState = PersistenceUtils.serializeState(state, digestFn);

  // Decide whether or not to do the write. The decision varies depending on whether or
  // not the channel supports offline delivery. If we decide not to do the write, then
  // that means the in-memory and stored state match semantically, and the train stops.
  if (config.getChannelSupportsOfflineDelivery()) {
    // For offline delivery, we want the entire state to match, since we write the last
    // send time for every message.
    if (state.equals(lastWrittenState.get())) {
      return false;
    }
  } else {
    // If we do not support offline delivery, we avoid writing the state on each message, and
    // we avoid checking the last-sent time (we check only the client token).
    if (TypedUtil.<Bytes>equals(
        state.getClientToken(), lastWrittenState.get().getClientToken())) {
      return false;
    }
  }

  // We decided to do the write.
  storage.writeKey(CLIENT_TOKEN_KEY, serializedState, new Callback<Status>() {
    @Override
    public void accept(Status status) {
      logger.info("Write state completed: %s for %s", status, state);
      Preconditions.checkState(resources.getInternalScheduler().isRunningOnThread());
      if (status.isSuccess()) {
        // Set lastWrittenToken to be the token that was written (NOT clientToken - which
        // could have changed while the write was happening).
        lastWrittenState.set(state);
      } else {
        statistics.recordError(ClientErrorType.PERSISTENT_WRITE_FAILURE);
      }
    }
  });
  return true;  // Reschedule after timeout to make sure that write does happen.
}
 

import com.google.ipc.invalidation.external.client.types.Status; //导入依赖的package包/类
/**
 * Handles a {@code message} for a {@code ticl}. If the {@code ticl} is started, delivers the
 * message. If the {@code ticl} is not started, drops the message and clears the last message send
 * time in the Ticl persistent storage so that the Ticl will send a heartbeat the next time it
 * starts.
 */
private void handleServerMessage(boolean isTiclStarted, byte[] message) {
  if (isTiclStarted) {
    // Normal case -- message for a started Ticl. Deliver the message.
    resources.getNetworkListener().onMessageReceived(message);
    return;
  }
  // The Ticl isn't started. Rewrite persistent storage so that the last-send-time is a long
  // time ago. The next time the Ticl starts, it will send a message to the data center, which
  // ensures that it will be marked online and that the dropped message (or an equivalent) will
  // be delivered.
  // Android storage implementations are required to execute callbacks inline, so this code
  // all executes synchronously.
  resources.getLogger().fine("Message for unstarted Ticl; rewrite state");
  resources.getStorage().readKey(InvalidationClientCore.CLIENT_TOKEN_KEY,
      new Callback<SimplePair<Status, byte[]>>() {
    @Override
    public void accept(SimplePair<Status, byte[]> result) {
      byte[] stateBytes = result.second;
      if (stateBytes == null) {
        resources.getLogger().info("No persistent state found for client; not rewriting");
        return;
      }
      // Create new state identical to the old state except with a cleared
      // lastMessageSendTimeMs.
      PersistentTiclState state = PersistenceUtils.deserializeState(
          resources.getLogger(), stateBytes, digestFn);
      if (state == null) {
        resources.getLogger().warning("Ignoring invalid Ticl state: %s", stateBytes);
        return;
      }
      PersistentTiclState newState = PersistentTiclState.newBuilder(state)
          .setLastMessageSendTimeMs(0)
          .build();

      // Serialize the new state and write it to storage.
      byte[] newClientState = PersistenceUtils.serializeState(newState, digestFn);
      resources.getStorage().writeKey(InvalidationClientCore.CLIENT_TOKEN_KEY, newClientState,
          new Callback<Status>() {
            @Override
            public void accept(Status status) {
              if (status.getCode() != Status.Code.SUCCESS) {
                resources.getLogger().warning(
                    "Failed saving rewritten persistent state to storage");
              }
            }
      });
    }
  });
}
 

import com.google.ipc.invalidation.external.client.types.Status; //导入依赖的package包/类
@Override
public boolean runTask() {
  if (clientToken == null) {
    // We cannot write without a token. We must do this check before creating the
    // PersistentTiclState because newPersistentTiclState cannot handle null tokens.
    return false;
  }

  // Compute the state that we will write if we decide to go ahead with the write.
  final ProtoWrapper<PersistentTiclState> state =
      ProtoWrapper.of(CommonProtos2.newPersistentTiclState(clientToken, lastMessageSendTimeMs));
  byte[] serializedState = PersistenceUtils.serializeState(state.getProto(), digestFn);

  // Decide whether or not to do the write. The decision varies depending on whether or
  // not the channel supports offline delivery. If we decide not to do the write, then
  // that means the in-memory and stored state match semantically, and the train stops.
  if (config.getChannelSupportsOfflineDelivery()) {
    // For offline delivery, we want the entire state to match, since we write the last
    // send time for every message.
    if (state.equals(lastWrittenState.get())) {
      return false;
    }
  } else {
    // If we do not support offline delivery, we avoid writing the state on each message, and
    // we avoid checking the last-sent time (we check only the client token).
    if (state.getProto().getClientToken().equals(
            lastWrittenState.get().getProto().getClientToken())) {
      return false;
    }
  }

  // We decided to do the write.
  storage.writeKey(CLIENT_TOKEN_KEY, serializedState, new Callback<Status>() {
    @Override
    public void accept(Status status) {
      logger.info("Write state completed: %s for %s", status, state.getProto());
      Preconditions.checkState(resources.getInternalScheduler().isRunningOnThread());
      if (status.isSuccess()) {
        // Set lastWrittenToken to be the token that was written (NOT clientToken - which
        // could have changed while the write was happening).
        lastWrittenState.set(state);
      } else {
        statistics.recordError(ClientErrorType.PERSISTENT_WRITE_FAILURE);
      }
    }
  });
  return true;  // Reschedule after timeout to make sure that write does happen.
}
 

import com.google.ipc.invalidation.external.client.types.Status; //导入依赖的package包/类
/**
 * Attempts to persist {@code value} for the given {@code key}. Invokes {@code done} when
 * finished, passing a value that indicates whether it was successful.
 * <p>
 * Note: If a wrie W1 finishes unsuccessfully and then W2 is issued for the same key and W2
 * finishes successfully, W1 must NOT later overwrite W2.
 * <p>
 * REQUIRES: Neither {@code key} nor {@code value} is null.
 */
void writeKey(String key, byte[] value, Callback<Status> done);
 

import com.google.ipc.invalidation.external.client.types.Status; //导入依赖的package包/类
/**
 * Reads the value corresponding to {@code key} and calls {@code done} with the result.
 * If it finds the key, passes a success status and the value. Else passes a failure status
 * and a null value.
 */
void readKey(String key, Callback<SimplePair<Status, byte[]>> done);
 

import com.google.ipc.invalidation.external.client.types.Status; //导入依赖的package包/类
/**
 * Reads all the keys from the underlying store and then calls {@code keyCallback} with
 * each key that was written earlier and not deleted. When all the keys are done, calls
 * {@code keyCallback} with {@code null}. With each key, the code can indicate a
 * failed status, in which case the iteration stops.
 */
void readAllKeys(Callback<SimplePair<Status, String>> keyCallback);