import com.contentful.vault.Vault; //导入依赖的package包/类
public void requestModels() {
  final CDAClient client = CDAClient.builder()
      .setSpace(VRSpace.SPACE_ID)
      .setToken(VRSpace.ACCESS_TOKEN)
      .build();

  vault.requestSync(client);

  Vault.observeSyncResults()
      .subscribeOn(Schedulers.io())
      .flatMap(new Func1<SyncResult, Observable<Product>>() {
        @Override public Observable<Product> call(SyncResult syncResult) {
          return vault.observe(Product.class).order(Product$Fields.NAME).all();
        }
      })
      .flatMap(new CreateProtoModelAndRenderSign(applicationContext))
      .flatMap(new DownloadMeshAsset(applicationContext))
      .flatMap(new DownloadTextureAsset(applicationContext))
      .observeOn(AndroidSchedulers.mainThread())
      .subscribe(new EnqueueProtoModel());
}
 

import com.contentful.vault.Vault; //导入依赖的package包/类
public void bind(final Listener listener) {
  if (listener == null) {
    throw new IllegalArgumentException("Listener cannot be null!");
  }

  vaultSyncSubscription = Vault.observeSyncResults()
      .subscribeOn(Schedulers.io())
      .subscribe(new Action1<SyncResult>() {
        @Override public void call(SyncResult syncResult) {
          if (syncResult.isSuccessful()) {
            requestEvents(listener);
          } else {
            listener.onError(syncResult.error());
          }
        }
      });
}
 

import com.contentful.vault.Vault; //导入依赖的package包/类
@Override protected Result performLoad() {
  List<Product> products = Vault.with(App.get(), CatalogueSpace.class).fetch(Product.class).all();
  if (categoryRemoteId == null) {
    return new Result(products, null);
  }

  List<Product> filtered = new ArrayList<>();
  Category targetCategory = null;
  for (Product product : products) {
    for (Category category : product.categories()) {
      if (categoryRemoteId.equals(category.remoteId())) {
        filtered.add(product);
        targetCategory = category;
        break;
      }
    }
  }
  return new Result(filtered, targetCategory);
}
 

import com.contentful.vault.Vault; //导入依赖的package包/类
private Map<Category, Integer> getCategoriesWithCount() {
  Vault vault = Vault.with(App.get(), CatalogueSpace.class);

  List<Category> categories = vault.fetch(Category.class).all();
  Map<Category, Integer> res = new HashMap<>();
  for (Category category : categories) {
    SQLiteDatabase db = vault.getReadableDatabase();
    int count = 0;
    Cursor cursor = db.rawQuery(QUERY_CATEGORY_COUNT, new String[] { category.remoteId() });
    try {
      if (cursor.moveToFirst()) {
        count = cursor.getInt(0);
      }
    } finally {
      cursor.close();
    }
    res.put(category, count);
  }

  return res;
}
 

import com.contentful.vault.Vault; //导入依赖的package包/类
@Test public void observeSyncResults() throws Exception {
  enqueue("demo/space.json");
  enqueue("demo/types.json");
  enqueue("demo/initial.json");

  TestSubscriber<SyncResult> subscriber = new TestSubscriber<>();
  Vault.observeSyncResults().subscribe(subscriber);

  subscriber.assertNoValues();
  sync();
  subscriber.assertNoErrors();

  List<SyncResult> events = subscriber.values();
  assertThat(events).hasSize(1);
  assertThat(events.get(0).isSuccessful()).isTrue();
  assertThat(events.get(0).spaceId()).isEqualTo("cfexampleapi");
}
 

import com.contentful.vault.Vault; //导入依赖的package包/类
@Override protected Result performLoad() {
  Vault vault = Vault.with(getContext(), BlogSpace.class);
  List<Post> posts = vault.fetch(Post.class).all();
  if (authorRemoteId == null) {
    return new Result(posts, null);
  }

  Author author = vault.fetch(Author.class)
      .where("remote_id = ?", authorRemoteId)
      .first();

  List<Post> filtered = new ArrayList<>();
  if (author != null) {
    for (Post post : posts) {
      if (postAuthorMatches(post, authorRemoteId)) {
        filtered.add(post);
      }
    }
  }

  return new Result(filtered, author);
}
 

import com.contentful.vault.Vault; //导入依赖的package包/类
private void createVault() {
  if (vault == null) {
    vault = Vault.with(this, EventSpace.class);
    vault.requestSync(CDAClient
        .builder()
        .setToken(EventSpace.DELIVERY_API_KEY)
        .setSpace(EventSpace.SPACE_ID)
        .setCallFactory(createCustomCallFactory())
        .build());
  }
}
 

import com.contentful.vault.Vault; //导入依赖的package包/类
private void setupReloadReceiver(boolean register) {
  if (register) {
    if (reloadReceiver == null) {
      reloadReceiver = new BroadcastReceiver() {
        @Override public void onReceive(Context context, Intent intent) {
          getSupportLoaderManager().restartLoader(LOADER_ID, null, MainActivity.this);
        }
      };
    }

    registerReceiver(reloadReceiver, new IntentFilter(Vault.ACTION_SYNC_COMPLETE));
  } else {
    unregisterReceiver(reloadReceiver);
  }
}
 

import com.contentful.vault.Vault; //导入依赖的package包/类
public static void requestSync(boolean invalidate) {
  Vault.with(get(), GallerySpace.class).requestSync(
      SyncConfig.builder()
          .setClient(ClientProvider.get())
          .setInvalidate(invalidate)
          .build());
}
 

import com.contentful.vault.Vault; //导入依赖的package包/类
public static void requestSync(boolean invalidate) {
  Vault.with(get(), CatalogueSpace.class).requestSync(
      SyncConfig.builder()
          .setClient(ClientProvider.get())
          .setInvalidate(invalidate)
          .build());
}
 

import com.contentful.vault.Vault; //导入依赖的package包/类
@Test public void testUpgrade() throws Exception {
  Vault v = vault;
  v.getReadableDatabase();
  v.releaseAll();
  v = Vault.with(RuntimeEnvironment.application, Sp2.class);
  v.getReadableDatabase();
}
 

import com.contentful.vault.Vault; //导入依赖的package包/类
@Test public void failsInvalidSpaceClass() throws Exception {
  try {
    Vault.with(RuntimeEnvironment.application, Object.class);
    fail();
  } catch (RuntimeException e) {
    assertThat(e.getMessage()).isEqualTo(
        "Cannot find generated class for space: java.lang.Object");
  }
}
 

import com.contentful.vault.Vault; //导入依赖的package包/类
@Override protected void onCreate(Bundle savedInstanceState) {
  super.onCreate(savedInstanceState);
  setContentView(R.layout.activity_list);
  ButterKnife.bind(this);

  adapter = createAdapter();
  createReceivers();
  registerReceiver(reloadReceiver, new IntentFilter(Vault.ACTION_SYNC_COMPLETE));
  initList();
  initSwipeRefresh();
  initLoader();
}
 

import com.contentful.vault.Vault; //导入依赖的package包/类
public static void requestSync(boolean invalidate) {
  Vault.with(get(), BlogSpace.class).requestSync(
      SyncConfig.builder()
          .setClient(ClientProvider.get())
          .setInvalidate(invalidate)
          .build());
}
 

import com.contentful.vault.Vault; //导入依赖的package包/类
public ContentfulInteractor(Context applicationContext) {
  this(applicationContext, Vault.with(applicationContext, VRSpace.class));
}
 

import com.contentful.vault.Vault; //导入依赖的package包/类
public EventListInteractor(Vault vault) {
  this.vault = vault;
}
 

import com.contentful.vault.Vault; //导入依赖的package包/类
public EventListPresenter(Vault vault) {
  this(new EventListInteractor(vault));
}
 

import com.contentful.vault.Vault; //导入依赖的package包/类
@Override protected List<Gallery> performLoad() {
  return Vault.with(getContext(), GallerySpace.class).fetch(Gallery.class).all();
}
 

import com.contentful.vault.Vault; //导入依赖的package包/类
@Override public void onCreate(Bundle savedInstanceState) {
  super.onCreate(savedInstanceState);

  createReceivers();
  getActivity().registerReceiver(reloadReceiver, new IntentFilter(Vault.ACTION_SYNC_COMPLETE));
}
 

import com.contentful.vault.Vault; //导入依赖的package包/类
@Override protected void setupVault() {
  vault = Vault.with(RuntimeEnvironment.application, VaultSpace.class);
}