android.arch.lifecycle.MutableLiveData Java Examples

public LiveData<Resource<Assignment>> saveAssignment(
        @NonNull Assignment assignment, String name, @Nullable Attachment attachment) {
    MutableLiveData<Resource<Assignment>> result = new MutableLiveData<>();
    new ResourceAsyncTask<>(result, () -> {
        if (attachment != null) {
            attachment.setModelCode(assignment.getCode());
            attachment.setModelType(ModelType.ASSIGNMENT);
            AttachmentsStore.getInstance().saveModel(attachment);
        }

        assignment.setName(name);

        AssignmentsStore.getInstance().saveModel(assignment);

        return Resource.success(assignment);
    }).execute();
    return result;
}
 

public LiveData<Resource<List<Assignment>>> updateOrders(List<Assignment> assignments) {
    MutableLiveData<Resource<List<Assignment>>> result = new MutableLiveData<>();
    new NormalAsyncTask<>(result, () -> {
        ((AssignmentsStore) getStore()).updateOrders(assignments);
        return assignments;
    }).execute();
    return result;
}
 

/**
 * Obtains an LiveData to <code>valueSet</code> property
 *
 * @return
 * an LiveData to <code>valueSet</code> property
 */
public MutableLiveData<HashSet<String>> getValueSetAsLiveData() {
  KriptonLiveDataHandlerImpl<HashSet<String>> liveData=new KriptonLiveDataHandlerImpl<HashSet<String>>() {
    @Override
    protected HashSet<String> compute() {
      BindApp1Preferences.this.refresh();
      return BindApp1Preferences.this.getValueSet();
    }
  };
  registryLiveData("value_set", liveData);
  return liveData.getLiveData();
}
 

LiveData<User> getUser() {
    if (userMutableLiveData == null) {
        userMutableLiveData = new MutableLiveData<>();
    }

    return userMutableLiveData;
}
 

/**
 * Obtains an LiveData to <code>right</code> property
 *
 * @return
 * an LiveData to <code>right</code> property
 */
public MutableLiveData<Integer> getRightAsLiveData() {
  KriptonLiveDataHandlerImpl<Integer> liveData=new KriptonLiveDataHandlerImpl<Integer>() {
    @Override
    protected Integer compute() {
      BindApp1Preferences.this.refresh();
      return BindApp1Preferences.this.getRight();
    }
  };
  registryLiveData("right", liveData);
  return liveData.getLiveData();
}
 

public MutableLiveData<List<CommunityModel>> getCommunities(CommunitySelectionPageCallback communitySelectionPageCallback) {
  if (communities == null) {
    communities = new MutableLiveData<>();
    fetchCommunities();
  }
  this.communitySelectionPageCallback = communitySelectionPageCallback;
  return communities;
}
 

/**
 * Obtains an LiveData to <code>valueBoolean</code> property
 *
 * @return
 * an LiveData to <code>valueBoolean</code> property
 */
public MutableLiveData<Boolean> getValueBooleanAsLiveData() {
  KriptonLiveDataHandlerImpl<Boolean> liveData=new KriptonLiveDataHandlerImpl<Boolean>() {
    @Override
    protected Boolean compute() {
      BindAppPreferences.this.refresh();
      return BindAppPreferences.this.getValueBoolean();
    }
  };
  registryLiveData("value_boolean", liveData);
  return liveData.getLiveData();
}
 

public LiveData<Resource<List<Directory>>> getDirectories(String itemId) {
    MutableLiveData<Resource<List<Directory>>> result = new MutableLiveData<>();
    OneDriveManager.getInstance().getItems(itemId, new ICallback<Item>() {
        @Override
        public void success(Item item) {
            if (item.children == null || item.children.getCurrentPage().isEmpty()) {
                // The folder is empty
                result.setValue(Resource.success(new LinkedList<>()));
            } else {
                // Return the children folder
                List<Directory> list = new LinkedList<>();
                LogUtils.d(item.children);
                for (final Item childItem : item.children.getCurrentPage()) {
                    if (childItem.folder == null) continue;
                    list.add(OneDriveManager.getDirectory(childItem));
                }
                result.setValue(Resource.success(list));
            }
        }

        @Override
        public void failure(ClientException ex) {
            result.setValue(Resource.error(ex.getMessage(), null));
        }
    });
    return result;
}
 

public LiveData<Lcee<Projects>> getProjects() {
    if (null == ldProjects) {
        ldPage = new MutableLiveData<>();
        ldProjects = Transformations.switchMap(ldPage, new Function<Integer, LiveData<Lcee<Projects>>>() {
            @Override
            public LiveData<Lcee<Projects>> apply(Integer page) {
                return projectsRepository.getProjects(page);
            }
        });
    }
    return ldProjects;
}
 

public CompanionViewModel(Application application) {
    super(application);
    mGoogleApiClient = NearbyConnectionManager.createNearbyApiClient(application);
    mRobocarDiscoverer = new RobocarDiscoverer(mGoogleApiClient);

    mNavigationState = new MutableLiveData<>();
    mNavigationState.setValue(NavigationState.DISCOVERY_UI);
}
 

/**
 * Obtains an LiveData to <code>description</code> property
 *
 * @return
 * an LiveData to <code>description</code> property
 */
public MutableLiveData<String> getDescriptionAsLiveData() {
  KriptonLiveDataHandlerImpl<String> liveData=new KriptonLiveDataHandlerImpl<String>() {
    @Override
    protected String compute() {
      BindAppPreferences.this.refresh();
      return BindAppPreferences.this.getDescription();
    }
  };
  registryLiveData("description", liveData);
  return liveData.getLiveData();
}
 

/**
 * Obtains an LiveData to <code>stringArray</code> property
 *
 * @return
 * an LiveData to <code>stringArray</code> property
 */
public MutableLiveData<String[]> getStringArrayAsLiveData() {
  KriptonLiveDataHandlerImpl<String[]> liveData=new KriptonLiveDataHandlerImpl<String[]>() {
    @Override
    protected String[] compute() {
      BindAppPreferences.this.refresh();
      return BindAppPreferences.this.getStringArray();
    }
  };
  registryLiveData("string_array", liveData);
  return liveData.getLiveData();
}
 

/**
 * Obtains an LiveData to <code>valueBoolean</code> property
 *
 * @return
 * an LiveData to <code>valueBoolean</code> property
 */
public MutableLiveData<Boolean> getValueBooleanAsLiveData() {
  KriptonLiveDataHandlerImpl<Boolean> liveData=new KriptonLiveDataHandlerImpl<Boolean>() {
    @Override
    protected Boolean compute() {
      BindAppPreferences.this.refresh();
      return BindAppPreferences.this.getValueBoolean();
    }
  };
  registryLiveData("value_boolean", liveData);
  return liveData.getLiveData();
}
 

public LiveData<Resource<T>> update(T model) {
    MutableLiveData<Resource<T>> result = new MutableLiveData<>();
    new NormalAsyncTask<>(result, () -> {
        getStore().update(model);
        return model;
    }).execute();
    return result;
}
 

public LiveData<Resource<T>> update(T model, Status toStatus) {
    MutableLiveData<Resource<T>> result = new MutableLiveData<>();
    new NormalAsyncTask<>(result, () -> {
        getStore().update(model, toStatus);
        return model;
    }).execute();
    return result;
}
 

public LiveData<Resource<T>> saveOrUpdate(T model) {
    MutableLiveData<Resource<T>> result = new MutableLiveData<>();
    new NormalAsyncTask<>(result, () -> {
        getStore().saveOrUpdate(model);
        return model;
    }).execute();
    return result;
}
 

@Inject
public ShareLocationViewModel(Application application,
                              DeviceLocationDataStore deviceLocationDataStore) {
    super(application);
    mDeviceLocationDataStore = deviceLocationDataStore;
    mSharingState = new MutableLiveData<>();
}
 

public LiveData<List<Earthquake>> getEarthquakes() {
  if (earthquakes == null) {
    earthquakes = new MutableLiveData<List<Earthquake>>();
    loadEarthquakes();
  }
  return earthquakes;
}
 

public LiveData<Resource<List<Assignment>>> getAssignments(
        long startMillis, long endMillis, boolean includeCompleted) {
    MutableLiveData<Resource<List<Assignment>>> result = new MutableLiveData<>();
    new NormalAsyncTask<>(result, () ->
            ((AssignmentsStore) getStore()).getAssignments(startMillis, endMillis,
                    (includeCompleted ? "" : AssignmentSchema.TABLE_NAME + "." + AssignmentSchema.PROGRESS + " != 100 "))
    ).execute();
    return result;
}
 

/**
 * Get all assignments to display fot today fragment: overdue assignments and those start today.
 *
 * @return the assignments */
public LiveData<Resource<List<Assignment>>> getToday() {
    MutableLiveData<Resource<List<Assignment>>> result = new MutableLiveData<>();
    new NormalAsyncTask<>(result, () -> {
        long todayEnd = TimeUtils.endToday().getTime();
        return getStore().get(AssignmentSchema.START_TIME + " <= " + todayEnd +
                " AND " + AssignmentSchema.PROGRESS + " != " + Constants.MAX_ASSIGNMENT_PROGRESS,
                AssignmentSchema.START_TIME + " DESC, " + AssignmentSchema.NOTICE_TIME, Status.NORMAL, false);
    }).execute();
    return result;
}
 

public LiveData<Lcee<User>> getUser() {
    if (null == ldUser) {
        ldUsername = new MutableLiveData<>();
        ldUser = Transformations.switchMap(ldUsername, new Function<String, LiveData<Lcee<User>>>() {
            @Override
            public LiveData<Lcee<User>> apply(String username) {
                return userRepository.getUser(username);
            }
        });
    }
    return ldUser;
}
 

@MainThread
public static MutableLiveData<Boolean> get() {
    if (sPermissionLiveData == null) {
        sPermissionLiveData = new MutableLiveData<>() ;
    }
    return sPermissionLiveData;
}
 

public LiveData<Resource<Category>> update(Category category, Status fromStatus, Status toStatus) {
    MutableLiveData<Resource<Category>> result = new MutableLiveData<>();
    new NormalAsyncTask<>(result, () -> {
        ((CategoryStore) getStore()).update(category, fromStatus, toStatus);
        return category;
    }).execute();
    return result;
}
 

/**
 * Obtains an LiveData to <code>name</code> property
 *
 * @return
 * an LiveData to <code>name</code> property
 */
public MutableLiveData<String> getNameAsLiveData() {
  KriptonLiveDataHandlerImpl<String> liveData=new KriptonLiveDataHandlerImpl<String>() {
    @Override
    protected String compute() {
      BindAppPreferences.this.refresh();
      return BindAppPreferences.this.getName();
    }
  };
  registryLiveData("name", liveData);
  return liveData.getLiveData();
}
 

public LiveData<Resource<Attachment>> saveIfNew(Attachment attachment) {
    MutableLiveData<Resource<Attachment>> result = new MutableLiveData<>();
    new NormalAsyncTask<>(result, () -> {
        if (getStore().isNewModel(attachment.getCode())) {
            getStore().saveModel(attachment);
        }
        return attachment;
    }).execute();
    return result;
}
 

public LiveData<Resource<List<Attachment>>> updateAttachments(Assignment assignment, List<Attachment> attachments) {
    MutableLiveData<Resource<List<Attachment>>> result = new MutableLiveData<>();
    new NormalAsyncTask<>(result, () -> {
        ((AttachmentsStore) getStore()).updateAttachments(assignment, attachments);
        return attachments;
    }).execute();
    return result;
}
 

public LiveData<Lcee<User>> getUser() {
    if (null == ldUser) {
        ldUsername = new MutableLiveData<>();
        ldUser = Transformations.switchMap(ldUsername, new Function<String, LiveData<Lcee<User>>>() {
            @Override
            public LiveData<Lcee<User>> apply(String username) {
                return userRepository.getUser(username);
            }
        });
    }
    return ldUser;
}
 

public LiveData<List<BlockUrlProvider>> getBlockUrlProviders() {
    if (blockUrlProviders == null) {
        blockUrlProviders = new MutableLiveData<>();
        loadBlockUrlProviders();
    }
    return blockUrlProviders;
}
 

public LiveData<PolicyPackage> getPolicyPackagesLiveData() {
    if (policyPackagesLiveData == null) {
        policyPackagesLiveData = new MutableLiveData<>();
        loadPolicyPackages();
    }
    return policyPackagesLiveData;
}
 

public BillingModel() {
    isSupportedLiveData = new MutableLiveData<>();
    isPremiumLiveData = new MutableLiveData<>();
    priceLiveData = new MutableLiveData<>();
    threeMonthPriceLiveData = new MutableLiveData<>();
    isSupportedLiveData.postValue(false);
    isPremiumLiveData.postValue(false);
    priceLiveData.postValue("");
}