sudoxreboot/habitica-android
1
0
Fork 0
mirror of https://github.com/sudoxnym/habitica-android.git synced 2026-04-14 19:56:32 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

rename APIHelper to ApiClient / IApiClient interface / remove uses of ApiService / use IApiClient instead / without compose calls

Browse source
This commit is contained in:
Negue 2017-01-28 20:27:35 +01:00
parent a841a4d4d8
commit 6106bb2fa3
61 changed files with 1044 additions and 558 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

504
Habitica/src/main/java/com/habitrpg/android/habitica/APIHelper.java → Habitica/src/main/java/com/habitrpg/android/habitica/ApiClient.java
View file

@ -10,9 +10,10 @@ import com.amplitude.api.Amplitude;
import com.habitrpg.android.habitica.database.CheckListItemExcludeStrategy;
import com.habitrpg.android.habitica.proxy.ifce.CrashlyticsProxy;
import com.habitrpg.android.habitica.helpers.PopupNotificationsManager;
import com.habitrpg.android.habitica.ui.helpers.DataBindingUtils;
import com.magicmicky.habitrpgwrapper.lib.api.ApiService;
import com.magicmicky.habitrpgwrapper.lib.api.IApiClient;
import com.magicmicky.habitrpgwrapper.lib.api.Server;
import com.magicmicky.habitrpgwrapper.lib.models.AchievementResult;
import com.magicmicky.habitrpgwrapper.lib.models.Challenge;
import com.magicmicky.habitrpgwrapper.lib.models.ChatMessage;
import com.magicmicky.habitrpgwrapper.lib.models.ContentResult;
@ -20,10 +21,16 @@ import com.magicmicky.habitrpgwrapper.lib.models.Customization;
import com.magicmicky.habitrpgwrapper.lib.models.FAQArticle;
import com.magicmicky.habitrpgwrapper.lib.models.Group;
import com.magicmicky.habitrpgwrapper.lib.models.HabitRPGUser;
import com.magicmicky.habitrpgwrapper.lib.models.Notification;
import com.magicmicky.habitrpgwrapper.lib.models.Items;
import com.magicmicky.habitrpgwrapper.lib.models.PostChatMessageResult;
import com.magicmicky.habitrpgwrapper.lib.models.PurchaseValidationRequest;
import com.magicmicky.habitrpgwrapper.lib.models.PurchaseValidationResult;
import com.magicmicky.habitrpgwrapper.lib.models.notifications.Reward;
import com.magicmicky.habitrpgwrapper.lib.models.Quest;
import com.magicmicky.habitrpgwrapper.lib.models.Shop;
import com.magicmicky.habitrpgwrapper.lib.models.Status;
import com.magicmicky.habitrpgwrapper.lib.models.Tag;
import com.magicmicky.habitrpgwrapper.lib.models.TaskDirectionData;
import com.magicmicky.habitrpgwrapper.lib.models.responses.BuyResponse;
import com.magicmicky.habitrpgwrapper.lib.models.responses.HabitResponse;
import com.magicmicky.habitrpgwrapper.lib.models.Purchases;
import com.magicmicky.habitrpgwrapper.lib.models.Skill;
@ -39,6 +46,8 @@ import com.magicmicky.habitrpgwrapper.lib.models.inventory.Mount;
import com.magicmicky.habitrpgwrapper.lib.models.inventory.Pet;
import com.magicmicky.habitrpgwrapper.lib.models.inventory.QuestContent;
import com.magicmicky.habitrpgwrapper.lib.models.responses.FeedResponse;
import com.magicmicky.habitrpgwrapper.lib.models.responses.SkillResponse;
import com.magicmicky.habitrpgwrapper.lib.models.responses.UnlockResponse;
import com.magicmicky.habitrpgwrapper.lib.models.tasks.ChecklistItem;
import com.magicmicky.habitrpgwrapper.lib.models.tasks.ItemData;
import com.magicmicky.habitrpgwrapper.lib.models.tasks.RemindersItem;
@ -71,21 +80,8 @@ import com.magicmicky.habitrpgwrapper.lib.utils.TaskTagDeserializer;
import com.magicmicky.habitrpgwrapper.lib.utils.TutorialStepListDeserializer;
import com.raizlabs.android.dbflow.structure.ModelAdapter;
import org.json.JSONException;
import org.json.JSONObject;
import android.app.Activity;
import android.media.Image;
import android.os.Build;
import android.support.v7.app.AlertDialog;
import android.util.Log;
import android.view.Gravity;
import android.view.LayoutInflater;
import android.view.View;
import android.widget.Button;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.TextView;
import java.io.IOException;
import java.lang.annotation.Annotation;
@ -102,11 +98,8 @@ import java.util.Map;
import javax.inject.Inject;
import javax.net.ssl.SSLException;
import okhttp3.Interceptor;
import okhttp3.MediaType;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import okhttp3.ResponseBody;
import okhttp3.logging.HttpLoggingInterceptor;
import retrofit2.Converter;
@ -122,18 +115,18 @@ import rx.functions.Func2;
import rx.schedulers.Schedulers;
public class APIHelper implements Action1<Throwable> {
@Inject
public class ApiClient implements Action1<Throwable>, IApiClient {
CrashlyticsProxy crashlyticsProxy;
// I think we don't need the APIHelper anymore we could just use ApiService
public final ApiService apiService;
// I think we don't need the ApiClient anymore we could just use ApiService
private final ApiService apiService;
final Observable.Transformer apiCallTransformer =
observable -> ((Observable) observable)
.map(new Func1<HabitResponse, Object>() {
@Override public Object call(HabitResponse habitResponse) {
if (habitResponse.notifications != null) {
PopupNotificationsManager popupNotificationsManager = PopupNotificationsManager.getInstance(APIHelper.this);
PopupNotificationsManager popupNotificationsManager = PopupNotificationsManager.getInstance(ApiClient.this);
popupNotificationsManager.showNotificationDialog(habitResponse.notifications);
}
return habitResponse.getData();
@ -151,7 +144,7 @@ public class APIHelper implements Action1<Throwable> {
//private OnHabitsAPIResult mResultListener;
//private HostConfig mConfig;
public APIHelper(GsonConverterFactory gsonConverter, HostConfig hostConfig) {
public ApiClient(GsonConverterFactory gsonConverter, HostConfig hostConfig, CrashlyticsProxy crashlyticsProxy) {
this.gsonConverter = gsonConverter;
this.hostConfig = hostConfig;
HabiticaBaseApplication.getComponent().inject(this);
@ -269,30 +262,31 @@ public class APIHelper implements Action1<Throwable> {
return GsonConverterFactory.create(gson);
}
public Observable<HabitResponse<UserAuthResponse>> registerUser(String username, String email, String password, String confirmPassword) {
public Observable<UserAuthResponse> registerUser(String username, String email, String password, String confirmPassword) {
UserAuth auth = new UserAuth();
auth.setUsername(username);
auth.setPassword(password);
auth.setConfirmPassword(confirmPassword);
auth.setEmail(email);
return this.apiService.registerUser(auth);
return this.apiService.registerUser(auth).compose(configureApiCallObserver());
}
public Observable<HabitResponse<UserAuthResponse>> connectUser(String username, String password) {
public Observable<UserAuthResponse> connectUser(String username, String password) {
UserAuth auth = new UserAuth();
auth.setUsername(username);
auth.setPassword(password);
return this.apiService.connectLocal(auth);
return this.apiService.connectLocal(auth).compose(configureApiCallObserver());
}
public Observable<HabitResponse<UserAuthResponse>> connectSocial(String network, String userId, String accessToken) {
public Observable<UserAuthResponse> connectSocial(String network, String userId, String accessToken) {
UserAuthSocial auth = new UserAuthSocial();
auth.setNetwork(network);
UserAuthSocialTokens authResponse = new UserAuthSocialTokens();
authResponse.setClient_id(userId);
authResponse.setAccess_token(accessToken);
auth.setAuthResponse(authResponse);
return this.apiService.connectSocial(auth);
return this.apiService.connectSocial(auth).compose(configureApiCallObserver());
}
@Override
@ -341,42 +335,40 @@ public class APIHelper implements Action1<Throwable> {
}
}
public Observable<HabitResponse<HabitRPGUser>> retrieveUser(boolean withTasks) {
Observable<HabitResponse<HabitRPGUser>> userObservable = apiService.getUser();
public Observable<HabitRPGUser> retrieveUser(boolean withTasks) {
Observable<HabitRPGUser> userObservable = apiService.getUser()
.compose(configureApiCallObserver());
if (withTasks) {
Observable<HabitResponse<TaskList>> tasksObservable = apiService.getTasks();
userObservable = Observable.zip(userObservable, tasksObservable,
new Func2<HabitResponse<HabitRPGUser>, HabitResponse<TaskList>, HabitResponse<HabitRPGUser>>() {
@Override
public HabitResponse<HabitRPGUser> call(HabitResponse<HabitRPGUser> habitRPGUserHabitResponse, HabitResponse<TaskList> taskListHabitResponse) {
HabitRPGUser habitRPGUser = habitRPGUserHabitResponse.getData();
TaskList tasks = taskListHabitResponse.getData();
(habitRPGUser, taskListHabitResponse) -> {
TaskList tasks = taskListHabitResponse.getData();
habitRPGUser.setHabits(sortTasks(tasks.tasks, habitRPGUser.getTasksOrder().getHabits()));
habitRPGUser.setDailys(sortTasks(tasks.tasks, habitRPGUser.getTasksOrder().getDailys()));
habitRPGUser.setTodos(sortTasks(tasks.tasks, habitRPGUser.getTasksOrder().getTodos()));
habitRPGUser.setRewards(sortTasks(tasks.tasks, habitRPGUser.getTasksOrder().getRewards()));
for (Task task : tasks.tasks.values()) {
switch (task.getType()) {
case "habit":
habitRPGUser.getHabits().add(task);
break;
case "daily":
habitRPGUser.getDailys().add(task);
break;
case "todo":
habitRPGUser.getTodos().add(task);
break;
case "reward":
habitRPGUser.getRewards().add(task);
break;
}
habitRPGUser.setHabits(sortTasks(tasks.tasks, habitRPGUser.getTasksOrder().getHabits()));
habitRPGUser.setDailys(sortTasks(tasks.tasks, habitRPGUser.getTasksOrder().getDailys()));
habitRPGUser.setTodos(sortTasks(tasks.tasks, habitRPGUser.getTasksOrder().getTodos()));
habitRPGUser.setRewards(sortTasks(tasks.tasks, habitRPGUser.getTasksOrder().getRewards()));
for (Task task : tasks.tasks.values()) {
switch (task.getType()) {
case "habit":
habitRPGUser.getHabits().add(task);
break;
case "daily":
habitRPGUser.getDailys().add(task);
break;
case "todo":
habitRPGUser.getTodos().add(task);
break;
case "reward":
habitRPGUser.getRewards().add(task);
break;
}
habitRPGUserHabitResponse.data = habitRPGUser;
return habitRPGUserHabitResponse;
}
return habitRPGUser;
});
}
return userObservable;
@ -449,11 +441,399 @@ public class APIHelper implements Action1<Throwable> {
Amplitude.getInstance().setUserId(this.hostConfig.getUser());
}
@Override
public void setLanguageCode(String languageCode) {
this.languageCode = languageCode;
}
@Override
public Observable<Status> getStatus() {
return apiService.getStatus().compose(configureApiCallObserver());
}
@Override
public Observable<ContentResult> getContent(String language) {
return apiService.getContent(language).compose(configureApiCallObserver());
}
@Override
public Observable<HabitRPGUser> getUser() {
return apiService.getUser().compose(configureApiCallObserver());
}
@Override
public Observable<HabitRPGUser> updateUser(Map<String, Object> updateDictionary) {
return apiService.updateUser(updateDictionary).compose(configureApiCallObserver());
}
@Override
public Observable<HabitRPGUser> registrationLanguage(String registrationLanguage) {
return apiService.registrationLanguage(registrationLanguage).compose(configureApiCallObserver());
}
@Override
public Observable<List<ItemData>> getInventoryBuyableGear() {
return apiService.getInventoryBuyableGear().compose(configureApiCallObserver());
}
@Override
public Observable<Items> equipItem(String type, String itemKey) {
return apiService.equipItem(type, itemKey).compose(configureApiCallObserver());
}
@Override
public Observable<BuyResponse> buyItem(String itemKey) {
return apiService.buyItem(itemKey).compose(configureApiCallObserver());
}
@Override
public Observable<Void> purchaseItem(String type, String itemKey) {
return apiService.purchaseItem(type, itemKey).compose(configureApiCallObserver());
}
@Override
public Observable<Void> purchaseHourglassItem(String type, String itemKey) {
return apiService.purchaseHourglassItem(type, itemKey).compose(configureApiCallObserver());
}
@Override
public Observable<Void> purchaseMysterySet(String itemKey) {
return apiService.purchaseMysterySet(itemKey).compose(configureApiCallObserver());
}
@Override
public Observable<Void> purchaseQuest(String key) {
return apiService.purchaseQuest(key).compose(configureApiCallObserver());
}
@Override
public Observable<HabitRPGUser> sellItem(String itemType, String itemKey) {
return apiService.sellItem(itemType, itemKey).compose(configureApiCallObserver());
}
@Override
public Observable<FeedResponse> feedPet(String petKey, String foodKey) {
return apiService.feedPet(petKey, foodKey).compose(configureApiCallObserver());
}
@Override
public Observable<Items> hatchPet(String eggKey, String hatchingPotionKey) {
return apiService.hatchPet(eggKey, hatchingPotionKey).compose(configureApiCallObserver());
}
@Override
public Observable<TaskList> getTasks() {
return apiService.getTasks().compose(configureApiCallObserver());
}
@Override
public Observable<UnlockResponse> unlockPath(String path) {
return apiService.unlockPath(path).compose(configureApiCallObserver());
}
@Override
public Observable<Task> getTask(String id) {
return apiService.getTask(id).compose(configureApiCallObserver());
}
@Override
public Observable<TaskDirectionData> postTaskDirection(String id, String direction) {
return apiService.postTaskDirection(id, direction).compose(configureApiCallObserver());
}
@Override
public Observable<ArrayList<String>> postTaskNewPosition(String id, String position) {
return apiService.postTaskNewPosition(id, position).compose(configureApiCallObserver());
}
@Override
public Observable<Task> scoreChecklistItem(String taskId, String itemId) {
return apiService.scoreChecklistItem(taskId, itemId).compose(configureApiCallObserver());
}
@Override
public Observable<Task> createItem(Task item) {
return apiService.createItem(item).compose(configureApiCallObserver());
}
@Override
public Observable<List<Task>> createTasks(List<Task> tasks) {
return apiService.createTasks(tasks).compose(configureApiCallObserver());
}
@Override
public Observable<Task> updateTask(String id, Task item) {
return apiService.updateTask(id, item).compose(configureApiCallObserver());
}
@Override
public Observable<Void> deleteTask(String id) {
return apiService.deleteTask(id).compose(configureApiCallObserver());
}
@Override
public Observable<Tag> createTag(Tag tag) {
return apiService.createTag(tag).compose(configureApiCallObserver());
}
@Override
public Observable<Tag> updateTag(String id, Tag tag) {
return apiService.updateTag(id, tag).compose(configureApiCallObserver());
}
@Override
public Observable<Void> deleteTag(String id) {
return apiService.deleteTag(id).compose(configureApiCallObserver());
}
@Override
public Observable<UserAuthResponse> registerUser(UserAuth auth) {
return apiService.registerUser(auth).compose(configureApiCallObserver());
}
@Override
public Observable<UserAuthResponse> connectLocal(UserAuth auth) {
return apiService.connectLocal(auth).compose(configureApiCallObserver());
}
@Override
public Observable<UserAuthResponse> connectSocial(UserAuthSocial auth) {
return apiService.connectSocial(auth).compose(configureApiCallObserver());
}
@Override
public Observable<Void> sleep() {
return apiService.sleep().compose(configureApiCallObserver());
}
@Override
public Observable<HabitRPGUser> revive() {
return apiService.revive().compose(configureApiCallObserver());
}
@Override
public Observable<SkillResponse> useSkill(String skillName, String targetType, String targetId) {
return apiService.useSkill(skillName, targetType, targetId).compose(configureApiCallObserver());
}
@Override
public Observable<SkillResponse> useSkill(String skillName, String targetType) {
return apiService.useSkill(skillName, targetType).compose(configureApiCallObserver());
}
@Override
public Observable<HabitRPGUser> changeClass() {
return apiService.changeClass().compose(configureApiCallObserver());
}
@Override
public Observable<HabitRPGUser> changeClass(String className) {
return apiService.changeClass(className).compose(configureApiCallObserver());
}
@Override
public Observable<HabitRPGUser> disableClasses() {
return apiService.disableClasses().compose(configureApiCallObserver());
}
@Override
public Observable<Void> markPrivateMessagesRead() {
return apiService.markPrivateMessagesRead().compose(configureApiCallObserver());
}
@Override
public Observable<List<Group>> listGroups(String type) {
return apiService.listGroups(type).compose(configureApiCallObserver());
}
@Override
public Observable<Group> getGroup(String groupId) {
return apiService.getGroup(groupId).compose(configureApiCallObserver());
}
@Override
public Observable<Void> updateGroup(String id, Group item) {
return apiService.updateGroup(id, item).compose(configureApiCallObserver());
}
@Override
public Observable<List<ChatMessage>> listGroupChat(String groupId) {
return apiService.listGroupChat(groupId).compose(configureApiCallObserver());
}
@Override
public Observable<Group> joinGroup(String groupId) {
return apiService.joinGroup(groupId).compose(configureApiCallObserver());
}
@Override
public Observable<Void> leaveGroup(String groupId) {
return apiService.leaveGroup(groupId).compose(configureApiCallObserver());
}
@Override
public Observable<PostChatMessageResult> postGroupChat(String groupId, HashMap<String, String> message) {
return apiService.postGroupChat(groupId, message).compose(configureApiCallObserver());
}
@Override
public Observable<Void> deleteMessage(String groupId, String messageId) {
return apiService.deleteMessage(groupId, messageId).compose(configureApiCallObserver());
}
@Override
public Observable<List<HabitRPGUser>> getGroupMembers(String groupId, Boolean includeAllPublicFields) {
return apiService.getGroupMembers(groupId, includeAllPublicFields).compose(configureApiCallObserver());
}
@Override
public Observable<List<HabitRPGUser>> getGroupMembers(String groupId, Boolean includeAllPublicFields, String lastId) {
return apiService.getGroupMembers(groupId, includeAllPublicFields, lastId).compose(configureApiCallObserver());
}
@Override
public Observable<ChatMessage> likeMessage(String groupId, String mid) {
return apiService.likeMessage(groupId, mid).compose(configureApiCallObserver());
}
@Override
public Observable<Void> flagMessage(String groupId, String mid) {
return apiService.flagMessage(groupId, mid).compose(configureApiCallObserver());
}
@Override
public Observable<Void> seenMessages(String groupId) {
return apiService.seenMessages(groupId).compose(configureApiCallObserver());
}
@Override
public Observable<Void> inviteToGroup(String groupId, Map<String, Object> inviteData) {
return apiService.inviteToGroup(groupId, inviteData).compose(configureApiCallObserver());
}
@Override
public Observable<Void> rejectGroupInvite(String groupId) {
return apiService.rejectGroupInvite(groupId).compose(configureApiCallObserver());
}
@Override
public Observable<Void> acceptQuest(String groupId) {
return apiService.acceptQuest(groupId).compose(configureApiCallObserver());
}
@Override
public Observable<Void> rejectQuest(String groupId) {
return apiService.rejectQuest(groupId).compose(configureApiCallObserver());
}
@Override
public Observable<Void> cancelQuest(String groupId) {
return apiService.cancelQuest(groupId).compose(configureApiCallObserver());
}
@Override
public Observable<Quest> forceStartQuest(String groupId, Group group) {
return apiService.forceStartQuest(groupId,group).compose(configureApiCallObserver());
}
@Override
public Observable<Quest> inviteToQuest(String groupId, String questKey) {
return apiService.inviteToQuest(groupId, questKey).compose(configureApiCallObserver());
}
@Override
public Observable<Quest> abortQuest(String groupId) {
return apiService.abortQuest(groupId).compose(configureApiCallObserver());
}
@Override
public Observable<Void> leaveQuest(String groupId) {
return apiService.leaveQuest(groupId).compose(configureApiCallObserver());
}
@Override
public Observable<PurchaseValidationResult> validatePurchase(PurchaseValidationRequest request) {
return apiService.validatePurchase(request).compose(configureApiCallObserver());
}
@Override
public Observable<HabitRPGUser> changeCustomDayStart(Map<String, Object> updateObject) {
return apiService.changeCustomDayStart(updateObject).compose(configureApiCallObserver());
}
@Override
public Observable<HabitRPGUser> GetMember(String memberId) {
return apiService.GetMember(memberId).compose(configureApiCallObserver());
}
@Override
public Observable<AchievementResult> GetMemberAchievements(String memberId) {
return apiService.GetMemberAchievements(memberId).compose(configureApiCallObserver());
}
@Override
public Observable<PostChatMessageResult> postPrivateMessage(HashMap<String, String> messageDetails) {
return apiService.postPrivateMessage(messageDetails).compose(configureApiCallObserver());
}
@Override
public Observable<Shop> fetchShopInventory(String identifier) {
return apiService.fetchShopInventory(identifier).compose(configureApiCallObserver());
}
@Override
public Observable<Void> addPushDevice(Map<String, String> pushDeviceData) {
return apiService.addPushDevice(pushDeviceData).compose(configureApiCallObserver());
}
@Override
public Observable<Void> deletePushDevice(String regId) {
return apiService.deletePushDevice(regId).compose(configureApiCallObserver());
}
@Override
public Observable<ArrayList<Challenge>> getUserChallenges() {
return apiService.getUserChallenges().compose(configureApiCallObserver());
}
@Override
public Observable<TaskList> getChallengeTasks(String challengeId) {
return apiService.getChallengeTasks(challengeId).compose(configureApiCallObserver());
}
@Override
public Observable<Challenge> getChallenge(String challengeId) {
return apiService.getChallenge(challengeId).compose(configureApiCallObserver());
}
@Override
public Observable<Challenge> joinChallenge(String challengeId) {
return apiService.joinChallenge(challengeId).compose(configureApiCallObserver());
}
@Override
public Observable<Void> leaveChallenge(String challengeId) {
return apiService.leaveChallenge(challengeId).compose(configureApiCallObserver());
}
@Override
public Observable<Void> debugAddTenGems() {
return apiService.debugAddTenGems().compose(configureApiCallObserver());
}
@Override
public Observable<Void> readNotificaiton(String notificationId) {
return apiService.readNotificaiton(notificationId).compose(configureApiCallObserver());
}
public static class ErrorResponse {
public String message;
}
public Observable<HabitResponse<ContentResult>>getContent() {
return apiService.getContent(languageCode);
public Observable<ContentResult>getContent() {
return apiService.getContent(languageCode).compose(configureApiCallObserver());
}
}

17
Habitica/src/main/java/com/habitrpg/android/habitica/ContentCache.java
View file

@ -1,5 +1,6 @@
package com.habitrpg.android.habitica;
import com.magicmicky.habitrpgwrapper.lib.api.IApiClient;
import com.magicmicky.habitrpgwrapper.lib.models.QuestBoss;
import com.magicmicky.habitrpgwrapper.lib.models.inventory.QuestContent;
import com.magicmicky.habitrpgwrapper.lib.models.tasks.ItemData;
@ -12,16 +13,14 @@ import java.util.Collection;
import java.util.List;
import rx.Observable;
import rx.android.schedulers.AndroidSchedulers;
import rx.schedulers.Schedulers;
public class ContentCache {
private APIHelper apiHelper;
private IApiClient apiClient;
public ContentCache(APIHelper apiHelper) {
this.apiHelper = apiHelper;
public ContentCache(IApiClient apiClient) {
this.apiClient = apiClient;
}
public void GetQuestContent(final String key, final QuestContentCallback cb) {
@ -71,8 +70,8 @@ public class ContentCache {
}
private <T> void getContentAndSearchFor(final String typeOfSearch, final String searchKey, final GotContentEntryCallback<T> gotEntry) {
apiHelper.getContent()
.compose(apiHelper.configureApiCallObserver())
apiClient.getContent()
.subscribe(contentResult -> {
switch (typeOfSearch) {
case "quest": {
@ -114,8 +113,8 @@ public class ContentCache {
private void getContentAndSearchForList(final String typeOfSearch, final List<String> searchKeys, final GotContentEntryCallback<List<ItemData>> gotEntry) {
List<ItemData> resultList = new ArrayList<>();
apiHelper.getContent()
.compose(apiHelper.configureApiCallObserver())
apiClient.getContent()
.flatMap(contentResult -> {
List<ItemData> itemList = new ArrayList<ItemData>(contentResult.gear.flat);
itemList.add(contentResult.potion);

13
Habitica/src/main/java/com/habitrpg/android/habitica/HabiticaBaseApplication.java
View file

@ -26,6 +26,7 @@ import com.habitrpg.android.habitica.helpers.PurchaseTypes;
import com.habitrpg.android.habitica.proxy.ifce.CrashlyticsProxy;
import com.habitrpg.android.habitica.ui.activities.IntroActivity;
import com.habitrpg.android.habitica.ui.activities.LoginActivity;
import com.magicmicky.habitrpgwrapper.lib.api.IApiClient;
import com.magicmicky.habitrpgwrapper.lib.models.HabitRPGUser;
import com.raizlabs.android.dbflow.config.FlowManager;
import com.squareup.leakcanary.LeakCanary;
@ -50,7 +51,7 @@ public abstract class HabiticaBaseApplication extends MultiDexApplication {
public static HabitRPGUser User;
public static Activity currentActivity = null;
@Inject
Lazy<APIHelper> lazyApiHelper;
Lazy<IApiClient> lazyApiHelper;
@Inject
SharedPreferences sharedPrefs;
@Inject
@ -158,15 +159,11 @@ public abstract class HabiticaBaseApplication extends MultiDexApplication {
int lastInstalledVersion = sharedPrefs.getInt("last_installed_version", 0);
if (lastInstalledVersion < info.versionCode) {
sharedPrefs.edit().putInt("last_installed_version", info.versionCode).apply();
APIHelper apiHelper = this.lazyApiHelper.get();
IApiClient apiClient = this.lazyApiHelper.get();
apiHelper.apiService.getContent(apiHelper.languageCode)
.compose(this.lazyApiHelper.get().configureApiCallObserver())
.subscribe(contentResult -> {
}, throwable -> {
});
apiClient.getContent()
.subscribe(contentResult -> { }, throwable -> {});
}
}
private void setupDagger() {

11
Habitica/src/main/java/com/habitrpg/android/habitica/HabiticaPurchaseVerifier.java
View file

@ -1,6 +1,7 @@
package com.habitrpg.android.habitica;
import com.habitrpg.android.habitica.helpers.PurchaseTypes;
import com.magicmicky.habitrpgwrapper.lib.api.IApiClient;
import com.magicmicky.habitrpgwrapper.lib.models.PurchaseValidationRequest;
import com.magicmicky.habitrpgwrapper.lib.models.PurchaseValidationResult;
import com.magicmicky.habitrpgwrapper.lib.models.Transaction;
@ -29,16 +30,16 @@ import retrofit2.adapter.rxjava.HttpException;
public class HabiticaPurchaseVerifier extends BasePurchaseVerifier {
private static final String PURCHASED_PRODUCTS_KEY = "PURCHASED_PRODUCTS";
private final APIHelper apiHelper;
private final IApiClient apiClient;
private Set<String> purchasedOrderList = new HashSet<>();
private SharedPreferences preferences;
public HabiticaPurchaseVerifier(Context context, APIHelper apiHelper) {
public HabiticaPurchaseVerifier(Context context, IApiClient apiClient) {
preferences = PreferenceManager.getDefaultSharedPreferences(context);
preferences.getStringSet(PURCHASED_PRODUCTS_KEY, purchasedOrderList);
this.apiHelper = apiHelper;
this.apiClient = apiClient;
}
@Override
@ -56,7 +57,7 @@ public class HabiticaPurchaseVerifier extends BasePurchaseVerifier {
validationRequest.transaction.receipt = purchase.data;
validationRequest.transaction.signature = purchase.signature;
apiHelper.apiService.validatePurchase(validationRequest).subscribe(purchaseValidationResult -> {
apiClient.validatePurchase(validationRequest).subscribe(purchaseValidationResult -> {
purchasedOrderList.add(purchase.orderId);
verifiedPurchases.add(purchase);
@ -76,7 +77,7 @@ public class HabiticaPurchaseVerifier extends BasePurchaseVerifier {
}, throwable -> {
if (throwable.getClass().equals(HttpException.class)) {
HttpException error = (HttpException)throwable;
APIHelper.ErrorResponse res = apiHelper.getErrorResponse((HttpException) throwable);
ApiClient.ErrorResponse res = apiClient.getErrorResponse((HttpException) throwable);
if (error.code() == 401) {
if (res.message.equals("RECEIPT_ALREADY_USED")) {
purchasedOrderList.add(purchase.orderId);

7
Habitica/src/main/java/com/habitrpg/android/habitica/components/AppComponent.java
View file

@ -1,6 +1,6 @@
package com.habitrpg.android.habitica.components;
import com.habitrpg.android.habitica.APIHelper;
import com.magicmicky.habitrpgwrapper.lib.api.IApiClient;
import com.habitrpg.android.habitica.HabiticaBaseApplication;
import com.habitrpg.android.habitica.helpers.RemindersManager;
import com.habitrpg.android.habitica.helpers.SoundManager;
@ -74,13 +74,14 @@ import com.habitrpg.android.habitica.widget.DailiesWidgetProvider;
import com.habitrpg.android.habitica.widget.HabitButtonWidgetProvider;
import com.habitrpg.android.habitica.widget.HabitButtonWidgetService;
import com.habitrpg.android.habitica.widget.TaskListWidgetProvider;
import com.magicmicky.habitrpgwrapper.lib.api.IApiClient;
import javax.inject.Singleton;
import dagger.Component;
@Singleton
@Component(modules = {AppModule.class, ApiModule.class, DeveloperModule.class, RepositoryModule.class})
@Component(modules = {DeveloperModule.class, AppModule.class, ApiModule.class, RepositoryModule.class})
public interface AppComponent {
void inject(ClassSelectionActivity classSelectionActivity);
@ -205,7 +206,7 @@ public interface AppComponent {
void inject(ChallengeDetailActivity challengeDetailActivity);
void inject(APIHelper apiHelper);
void inject(IApiClient apiClient);
void inject(TaskListWidgetProvider taskListWidgetProvider);

3
Habitica/src/main/java/com/habitrpg/android/habitica/data/TaskRepository.java
View file

@ -3,6 +3,7 @@ package com.habitrpg.android.habitica.data;
import com.magicmicky.habitrpgwrapper.lib.models.TaskDirectionData;
import com.magicmicky.habitrpgwrapper.lib.models.responses.HabitResponse;
import com.magicmicky.habitrpgwrapper.lib.models.tasks.Task;
import com.magicmicky.habitrpgwrapper.lib.models.tasks.TaskList;
import com.magicmicky.habitrpgwrapper.lib.models.tasks.TasksOrder;
import java.util.ArrayList;
@ -12,7 +13,7 @@ import rx.Observable;
public interface TaskRepository extends BaseRepository {
Observable<ArrayList<Task>> getTasks(String taskType);
Observable<HabitResponse<ArrayList<Task>>> refreshTasks(TasksOrder tasksOrder);
Observable<TaskList> refreshTasks(TasksOrder tasksOrder);
Observable<TaskDirectionData> scoreHabit(Task task, boolean up);
}

8
Habitica/src/main/java/com/habitrpg/android/habitica/data/implementation/BaseRepositoryImpl.java
View file

@ -2,16 +2,16 @@ package com.habitrpg.android.habitica.data.implementation;
import com.habitrpg.android.habitica.data.BaseRepository;
import com.habitrpg.android.habitica.data.local.BaseLocalRepository;
import com.magicmicky.habitrpgwrapper.lib.api.ApiService;
import com.magicmicky.habitrpgwrapper.lib.api.IApiClient;
public abstract class BaseRepositoryImpl<T extends BaseLocalRepository> implements BaseRepository {
protected final T localRepository;
protected final ApiService apiService;
protected final IApiClient apiClient;
public BaseRepositoryImpl(T localRepository, ApiService apiService) {
public BaseRepositoryImpl(T localRepository, IApiClient apiClient) {
this.localRepository = localRepository;
this.apiService = apiService;
this.apiClient = apiClient;
}
public void close() {

27
Habitica/src/main/java/com/habitrpg/android/habitica/data/implementation/TaskRepositoryImpl.java
View file

@ -1,15 +1,12 @@
package com.habitrpg.android.habitica.data.implementation;
import com.habitrpg.android.habitica.APIHelper;
import com.habitrpg.android.habitica.R;
import com.magicmicky.habitrpgwrapper.lib.api.IApiClient;
import com.habitrpg.android.habitica.data.TaskRepository;
import com.habitrpg.android.habitica.data.local.TaskLocalRepository;
import com.habitrpg.android.habitica.ui.helpers.UiUtils;
import com.magicmicky.habitrpgwrapper.lib.api.ApiService;
import com.magicmicky.habitrpgwrapper.lib.models.TaskDirection;
import com.magicmicky.habitrpgwrapper.lib.models.TaskDirectionData;
import com.magicmicky.habitrpgwrapper.lib.models.responses.HabitResponse;
import com.magicmicky.habitrpgwrapper.lib.models.tasks.Task;
import com.magicmicky.habitrpgwrapper.lib.models.tasks.TaskList;
import com.magicmicky.habitrpgwrapper.lib.models.tasks.TasksOrder;
import java.util.ArrayList;
@ -19,12 +16,8 @@ import rx.Observable;
public class TaskRepositoryImpl extends BaseRepositoryImpl<TaskLocalRepository> implements TaskRepository {
private APIHelper apiHelper;
public TaskRepositoryImpl(TaskLocalRepository localRepository, APIHelper apiHelper) {
super(localRepository, apiHelper.apiService);
this.apiHelper = apiHelper;
public TaskRepositoryImpl(TaskLocalRepository localRepository, IApiClient apiClient) {
super(localRepository, apiClient);
}
@Override
@ -33,25 +26,21 @@ public class TaskRepositoryImpl extends BaseRepositoryImpl<TaskLocalRepository>
}
@Override
public Observable<HabitResponse<ArrayList<Task>>> refreshTasks(TasksOrder tasksOrder) {
return this.apiService.getUserTasks()
.doOnNext(res -> this.localRepository.saveTasks(tasksOrder, res.data));
public Observable<TaskList> refreshTasks(TasksOrder tasksOrder) {
return this.apiClient.getTasks()
.doOnNext(res -> this.localRepository.saveTasks(tasksOrder, res));
}
@Override
public Observable<TaskDirectionData> scoreHabit(Task task, boolean up) {
return this.apiService.postTaskDirection(task.getId(), (up ? TaskDirection.up : TaskDirection.down).toString())
.compose(apiHelper.configureApiCallObserver())
return this.apiClient.postTaskDirection(task.getId(), (up ? TaskDirection.up : TaskDirection.down).toString())
.doOnNext(res -> {
// save local task changes
if (task != null && task.type != null && !task.type.equals("reward")) {
task.value = task.value + res.getDelta();
this.localRepository.saveTask(task);
}
// play sound
});
}
}

3
Habitica/src/main/java/com/habitrpg/android/habitica/data/local/TaskLocalRepository.java
View file

@ -1,6 +1,7 @@
package com.habitrpg.android.habitica.data.local;
import com.magicmicky.habitrpgwrapper.lib.models.tasks.Task;
import com.magicmicky.habitrpgwrapper.lib.models.tasks.TaskList;
import com.magicmicky.habitrpgwrapper.lib.models.tasks.TasksOrder;
import java.util.ArrayList;
@ -11,7 +12,7 @@ public interface TaskLocalRepository extends BaseLocalRepository {
Observable<ArrayList<Task>> getTasks(String taskType);
void saveTasks(TasksOrder tasksOrder, ArrayList<Task> tasks);
void saveTasks(TasksOrder tasksOrder, TaskList tasks);
void saveTask(Task task);
}

16
Habitica/src/main/java/com/habitrpg/android/habitica/data/local/implementation/DbFlowTaskLocalRepository.java
View file

@ -2,6 +2,7 @@ package com.habitrpg.android.habitica.data.local.implementation;
import com.habitrpg.android.habitica.data.local.TaskLocalRepository;
import com.magicmicky.habitrpgwrapper.lib.models.tasks.Task;
import com.magicmicky.habitrpgwrapper.lib.models.tasks.TaskList;
import com.magicmicky.habitrpgwrapper.lib.models.tasks.TasksOrder;
import java.util.ArrayList;
@ -18,7 +19,7 @@ public class DbFlowTaskLocalRepository implements TaskLocalRepository {
}
@Override
public void saveTasks(TasksOrder tasksOrder, ArrayList<Task> tasks) {
public void saveTasks(TasksOrder tasksOrder, TaskList tasks) {
sortTasks(tasks, tasksOrder.getHabits());
sortTasks(tasks, tasksOrder.getDailys());
sortTasks(tasks, tasksOrder.getTodos());
@ -39,26 +40,21 @@ public class DbFlowTaskLocalRepository implements TaskLocalRepository {
task.async().save();
}
private List<Task> sortTasks(List<Task> taskList, List<String> taskOrder) {
private List<Task> sortTasks(TaskList taskList, List<String> taskOrder) {
List<Task> taskResult = new ArrayList<>();
int position = 0;
HashMap<String, Task> taskMap = new HashMap<>();
for (Task t : taskList){
taskMap.put(t.getId(), t);
}
for (String taskId : taskOrder) {
Task task = taskMap.get(taskId);
Task task = taskList.tasks.get(taskId);
if (task != null) {
task.position = position;
taskResult.add(task);
position++;
taskMap.remove(taskId);
taskList.tasks.remove(taskId);
}
}
return taskList;
return taskResult;
}
@Override

21
Habitica/src/main/java/com/habitrpg/android/habitica/helpers/PopupNotificationsManager.java
View file

@ -4,15 +4,13 @@ import android.support.v7.app.AlertDialog;
import android.view.LayoutInflater;
import android.view.View;
import android.widget.Button;
import android.widget.ImageView;
import android.widget.TextView;
import com.facebook.drawee.backends.pipeline.Fresco;
import com.facebook.drawee.view.SimpleDraweeView;
import com.habitrpg.android.habitica.APIHelper;
import com.habitrpg.android.habitica.HabiticaApplication;
import com.habitrpg.android.habitica.R;
import com.habitrpg.android.habitica.ui.helpers.DataBindingUtils;
import com.magicmicky.habitrpgwrapper.lib.api.IApiClient;
import com.magicmicky.habitrpgwrapper.lib.models.Notification;
import com.magicmicky.habitrpgwrapper.lib.models.notifications.Reward;
@ -26,17 +24,17 @@ import java.util.Map;
public class PopupNotificationsManager {
private Map<String, Boolean> seenNotifications;
private APIHelper apiHelper;
private IApiClient apiClient;
private static PopupNotificationsManager instance;
// @TODO: A queue for displaying alert dialogues
private PopupNotificationsManager(APIHelper apiHelper) {
this.apiHelper = apiHelper;
private PopupNotificationsManager(IApiClient apiClient) {
this.apiClient = apiClient;
this.seenNotifications = new HashMap<>();
}
public static PopupNotificationsManager getInstance(APIHelper apiHelper) {
public static PopupNotificationsManager getInstance(IApiClient apiHelper) {
if (instance == null) {
instance = new PopupNotificationsManager(apiHelper);
}
@ -90,13 +88,10 @@ public class PopupNotificationsManager {
confirmButton.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
if (apiHelper != null) {
if (apiClient != null) {
// @TODO: This should be handled somewhere else? MAybe we notifiy via event
apiHelper.apiService.readNotificaiton(notification.getId())
.compose(apiHelper.configureApiCallObserver())
.subscribe(next -> {
}, throwable -> {
});
apiClient.readNotificaiton(notification.getId())
.subscribe(next -> {}, throwable -> {});
}
dialog.hide();

8
Habitica/src/main/java/com/habitrpg/android/habitica/helpers/notifications/HabiticaFirebaseInstanceIDService.java
View file

@ -1,15 +1,7 @@
package com.habitrpg.android.habitica.helpers.notifications;
import android.util.Log;
import com.google.firebase.iid.FirebaseInstanceId;
import com.google.firebase.iid.FirebaseInstanceIdService;
import com.habitrpg.android.habitica.APIHelper;
import java.util.HashMap;
import java.util.Map;
import javax.inject.Inject;
/**
* Created by keithholliday on 6/24/16.

14
Habitica/src/main/java/com/habitrpg/android/habitica/helpers/notifications/PushNotificationManager.java
View file

@ -3,13 +3,11 @@ package com.habitrpg.android.habitica.helpers.notifications;
import android.content.Context;
import android.content.SharedPreferences;
import android.preference.PreferenceManager;
import android.util.Log;
import com.google.firebase.iid.FirebaseInstanceId;
import com.google.firebase.messaging.RemoteMessage;
import com.habitrpg.android.habitica.APIHelper;
import com.magicmicky.habitrpgwrapper.lib.api.IApiClient;
import com.habitrpg.android.habitica.HabiticaApplication;
import com.habitrpg.android.habitica.callbacks.HabitRPGUserCallback;
import com.magicmicky.habitrpgwrapper.lib.models.HabitRPGUser;
import com.magicmicky.habitrpgwrapper.lib.models.PushDevice;
@ -37,7 +35,7 @@ public class PushNotificationManager {
@Inject
public APIHelper apiHelper;
public IApiClient apiClient;
private String refreshedToken;
private SharedPreferences sharedPreferences;
@ -96,14 +94,14 @@ public class PushNotificationManager {
Map<String, String> pushDeviceData = new HashMap<String, String>();
pushDeviceData.put("regId", this.refreshedToken);
pushDeviceData.put("type", "android");
apiHelper.apiService.addPushDevice(pushDeviceData)
.compose(apiHelper.configureApiCallObserver())
apiClient.addPushDevice(pushDeviceData)
.subscribe(aVoid -> {}, throwable -> {});
}
public void removePushDeviceUsingStoredToken () {
apiHelper.apiService.deletePushDevice(this.refreshedToken)
.compose(apiHelper.configureApiCallObserver())
apiClient.deletePushDevice(this.refreshedToken)
.subscribe(aVoid -> {}, throwable -> {});
}

1
Habitica/src/main/java/com/habitrpg/android/habitica/interactors/HabitScoreUseCase.java
View file

@ -5,7 +5,6 @@ import com.habitrpg.android.habitica.executors.PostExecutionThread;
import com.habitrpg.android.habitica.executors.ThreadExecutor;
import com.habitrpg.android.habitica.helpers.SoundManager;
import com.magicmicky.habitrpgwrapper.lib.models.TaskDirectionData;
import com.magicmicky.habitrpgwrapper.lib.models.responses.HabitResponse;
import com.magicmicky.habitrpgwrapper.lib.models.tasks.Task;
import javax.inject.Inject;

22
Habitica/src/main/java/com/habitrpg/android/habitica/modules/ApiModule.java
View file

@ -1,9 +1,10 @@
package com.habitrpg.android.habitica.modules;
import com.habitrpg.android.habitica.APIHelper;
import com.habitrpg.android.habitica.ApiClient;
import com.habitrpg.android.habitica.proxy.ifce.CrashlyticsProxy;
import com.magicmicky.habitrpgwrapper.lib.api.IApiClient;
import com.habitrpg.android.habitica.ContentCache;
import com.habitrpg.android.habitica.HostConfig;
import com.magicmicky.habitrpgwrapper.lib.api.ApiService;
import com.magicmicky.habitrpgwrapper.lib.api.MaintenanceApiService;
import android.content.Context;
@ -28,26 +29,19 @@ public class ApiModule {
@Provides
public GsonConverterFactory providesGsonConverterFactory() {
return APIHelper.createGsonFactory();
return ApiClient.createGsonFactory();
}
@Provides
@Singleton
public APIHelper providesApiHelper(GsonConverterFactory gsonConverter, HostConfig hostConfig) {
return new APIHelper(gsonConverter, hostConfig);
public IApiClient providesApiHelper(GsonConverterFactory gsonConverter, HostConfig hostConfig, CrashlyticsProxy crashlyticsProxy) {
return new ApiClient(gsonConverter, hostConfig, crashlyticsProxy);
}
@Provides
@Singleton
public ApiService providesApiService(APIHelper apiHelper) {
return apiHelper.apiService;
}
@Provides
@Singleton
public ContentCache providesContentCache(APIHelper helper){
return new ContentCache(helper);
public ContentCache providesContentCache(IApiClient client){
return new ContentCache(client);
}
@Provides

7
Habitica/src/main/java/com/habitrpg/android/habitica/modules/RepositoryModule.java
View file

@ -1,11 +1,10 @@
package com.habitrpg.android.habitica.modules;
import com.habitrpg.android.habitica.APIHelper;
import com.magicmicky.habitrpgwrapper.lib.api.IApiClient;
import com.habitrpg.android.habitica.data.TaskRepository;
import com.habitrpg.android.habitica.data.implementation.TaskRepositoryImpl;
import com.habitrpg.android.habitica.data.local.TaskLocalRepository;
import com.habitrpg.android.habitica.data.local.implementation.DbFlowTaskLocalRepository;
import com.magicmicky.habitrpgwrapper.lib.api.ApiService;
import dagger.Module;
import dagger.Provides;
@ -19,7 +18,7 @@ public class RepositoryModule {
}
@Provides
TaskRepository providesTaskRepository(TaskLocalRepository localRepository, APIHelper apiHelper) {
return new TaskRepositoryImpl(localRepository, apiHelper);
TaskRepository providesTaskRepository(TaskLocalRepository localRepository, IApiClient apiClient) {
return new TaskRepositoryImpl(localRepository, apiClient);
}
}

32
Habitica/src/main/java/com/habitrpg/android/habitica/receivers/LocalNotificationActionReceiver.java
View file

@ -6,9 +6,8 @@ import android.content.Context;
import android.content.Intent;
import android.content.res.Resources;
import android.os.Bundle;
import android.util.Log;
import com.habitrpg.android.habitica.APIHelper;
import com.magicmicky.habitrpgwrapper.lib.api.IApiClient;
import com.habitrpg.android.habitica.HabiticaApplication;
import com.habitrpg.android.habitica.R;
import com.habitrpg.android.habitica.callbacks.HabitRPGUserCallback;
@ -21,7 +20,7 @@ import javax.inject.Inject;
*/
public class LocalNotificationActionReceiver extends BroadcastReceiver implements HabitRPGUserCallback.OnUserReceived {
@Inject
public APIHelper apiHelper;
public IApiClient apiClient;
private HabitRPGUser user;
private String action;
@ -38,8 +37,7 @@ public class LocalNotificationActionReceiver extends BroadcastReceiver implement
this.intent = intent;
this.context = context;
this.apiHelper.apiService.getUser()
.compose(this.apiHelper.configureApiCallObserver())
this.apiClient.getUser()
.subscribe(new HabitRPGUserCallback(this), throwable -> {});
}
@ -57,40 +55,40 @@ public class LocalNotificationActionReceiver extends BroadcastReceiver implement
if (action.equals(this.resources.getString(R.string.accept_party_invite))) {
if (this.user.getInvitations().getParty() == null) return;
String partyId = this.user.getInvitations().getParty().getId();
apiHelper.apiService.joinGroup(partyId)
.compose(apiHelper.configureApiCallObserver())
apiClient.joinGroup(partyId)
.subscribe(aVoid -> {}, throwable -> {});
} else if (action.equals(this.resources.getString(R.string.reject_party_invite))) {
if (this.user.getInvitations().getParty() == null) return;
String partyId = this.user.getInvitations().getParty().getId();
apiHelper.apiService.rejectGroupInvite(partyId)
.compose(apiHelper.configureApiCallObserver())
apiClient.rejectGroupInvite(partyId)
.subscribe(aVoid -> {}, throwable -> {});
} else if (action.equals(this.resources.getString(R.string.accept_quest_invite))) {
if (this.user.getParty() == null) return;
String partyId = this.user.getParty().getId();
apiHelper.apiService.acceptQuest(partyId)
.compose(apiHelper.configureApiCallObserver())
apiClient.acceptQuest(partyId)
.subscribe(aVoid -> {}, throwable -> {});
} else if (action.equals(this.resources.getString(R.string.reject_quest_invite))) {
if (this.user.getParty() == null) return;
String partyId = this.user.getParty().getId();
apiHelper.apiService.rejectQuest(partyId)
.compose(apiHelper.configureApiCallObserver())
apiClient.rejectQuest(partyId)
.subscribe(aVoid -> {}, throwable -> {});
} else if (action.equals(this.resources.getString(R.string.accept_guild_invite))) {
Bundle extras = this.intent.getExtras();
String guildId = extras.getString("groupID");
if (guildId == null) return;
apiHelper.apiService.joinGroup(guildId)
.compose(apiHelper.configureApiCallObserver())
apiClient.joinGroup(guildId)
.subscribe(aVoid -> {}, throwable -> {});
} else if (action.equals(this.resources.getString(R.string.reject_guild_invite))) {
Bundle extras = this.intent.getExtras();
String guildId = extras.getString("groupID");
if (guildId == null) return;
apiHelper.apiService.rejectGroupInvite(guildId)
.compose(apiHelper.configureApiCallObserver())
apiClient.rejectGroupInvite(guildId)
.subscribe(aVoid -> {}, throwable -> {});
}
}

13
Habitica/src/main/java/com/habitrpg/android/habitica/ui/activities/ChallengeDetailActivity.java
View file

@ -15,7 +15,7 @@ import android.view.View;
import android.widget.LinearLayout;
import android.widget.TextView;
import com.habitrpg.android.habitica.APIHelper;
import com.magicmicky.habitrpgwrapper.lib.api.IApiClient;
import com.habitrpg.android.habitica.HabiticaApplication;
import com.habitrpg.android.habitica.R;
import com.habitrpg.android.habitica.components.AppComponent;
@ -50,7 +50,7 @@ public class ChallengeDetailActivity extends BaseActivity {
Toolbar toolbar;
@Inject
public APIHelper apiHelper;
public IApiClient apiClient;
private ChallengeViewHolder challengeViewHolder;
@ -84,8 +84,7 @@ public class ChallengeDetailActivity extends BaseActivity {
ObservableList<Task> fullList = new ObservableArrayList<>();
apiHelper.apiService.getChallengeTasks(challengeId)
.compose(this.apiHelper.configureApiCallObserver())
apiClient.getChallengeTasks(challengeId)
.subscribe(taskList -> {
ArrayList<Task> resultList = new ArrayList<>();
@ -227,7 +226,7 @@ public class ChallengeDetailActivity extends BaseActivity {
@OnClick(R.id.btn_show_more)
public void onShowMore() {
ChallegeDetailDialogHolder.showDialog(ChallengeDetailActivity.this, ChallengeDetailActivity.this.apiHelper,
ChallegeDetailDialogHolder.showDialog(ChallengeDetailActivity.this, ChallengeDetailActivity.this.apiClient,
HabiticaApplication.User, challenge,
challenge1 -> {
@ -244,8 +243,8 @@ public class ChallengeDetailActivity extends BaseActivity {
.setTitle(this.getString(R.string.challenge_leave_title))
.setMessage(String.format(this.getString(R.string.challenge_leave_text), challenge.name))
.setPositiveButton(this.getString(R.string.yes), (dialog, which) -> {
this.apiHelper.apiService.leaveChallenge(challenge.id)
.compose(apiHelper.configureApiCallObserver())
this.apiClient.leaveChallenge(challenge.id)
.subscribe(aVoid -> {
challenge.user_id = null;
challenge.async().save();

16
Habitica/src/main/java/com/habitrpg/android/habitica/ui/activities/ClassSelectionActivity.java
View file

@ -1,6 +1,6 @@
package com.habitrpg.android.habitica.ui.activities;
import com.habitrpg.android.habitica.APIHelper;
import com.magicmicky.habitrpgwrapper.lib.api.IApiClient;
import com.habitrpg.android.habitica.R;
import com.habitrpg.android.habitica.components.AppComponent;
import com.habitrpg.android.habitica.ui.AvatarView;
@ -10,7 +10,6 @@ import com.magicmicky.habitrpgwrapper.lib.models.Hair;
import com.magicmicky.habitrpgwrapper.lib.models.Items;
import com.magicmicky.habitrpgwrapper.lib.models.Outfit;
import com.magicmicky.habitrpgwrapper.lib.models.Preferences;
import com.magicmicky.habitrpgwrapper.lib.models.responses.HabitResponse;
import android.app.ProgressDialog;
import android.content.Intent;
@ -40,7 +39,7 @@ public class ClassSelectionActivity extends BaseActivity implements Action1<Habi
AvatarView warriorAvatarView;
@Inject
APIHelper apiHelper;
IApiClient apiClient;
ProgressDialog progressDialog;
@ -103,8 +102,7 @@ public class ClassSelectionActivity extends BaseActivity implements Action1<Habi
warriorAvatarView.setUser(warrior);
if (!isInitialSelection) {
apiHelper.apiService.changeClass()
.compose(apiHelper.configureApiCallObserver())
apiClient.changeClass()
.subscribe(user -> {
classWasUnset = true;
}, throwable -> {
@ -206,8 +204,8 @@ public class ClassSelectionActivity extends BaseActivity implements Action1<Habi
private void optOutOfClasses() {
shouldFinish = true;
this.displayProgressDialog();
apiHelper.apiService.disableClasses()
.compose(apiHelper.configureApiCallObserver())
apiClient.disableClasses()
.subscribe(this, throwable -> {
});
}
@ -215,8 +213,8 @@ public class ClassSelectionActivity extends BaseActivity implements Action1<Habi
private void selectClass(String selectedClass) {
shouldFinish = true;
this.displayProgressDialog();
apiHelper.apiService.changeClass(selectedClass)
.compose(apiHelper.configureApiCallObserver())
apiClient.changeClass(selectedClass)
.subscribe(this, throwable -> {
});
}

16
Habitica/src/main/java/com/habitrpg/android/habitica/ui/activities/FullProfileActivity.java
View file

@ -23,7 +23,7 @@ import com.facebook.drawee.backends.pipeline.Fresco;
import com.facebook.drawee.controller.BaseControllerListener;
import com.facebook.drawee.view.SimpleDraweeView;
import com.facebook.imagepipeline.image.ImageInfo;
import com.habitrpg.android.habitica.APIHelper;
import com.magicmicky.habitrpgwrapper.lib.api.IApiClient;
import com.habitrpg.android.habitica.ContentCache;
import com.habitrpg.android.habitica.HabiticaApplication;
import com.habitrpg.android.habitica.R;
@ -62,7 +62,7 @@ public class FullProfileActivity extends BaseActivity {
ContentCache contentCache;
@Inject
APIHelper apiHelper;
IApiClient apiClient;
@BindView(R.id.profile_image)
SimpleDraweeView profile_image;
@ -138,8 +138,8 @@ public class FullProfileActivity extends BaseActivity {
setTitle(R.string.profile_loading_data);
apiHelper.apiService.GetMember(this.userId)
.compose(apiHelper.configureApiCallObserver())
apiClient.GetMember(this.userId)
.subscribe(this::updateView,
throwable -> {
});
@ -189,8 +189,8 @@ public class FullProfileActivity extends BaseActivity {
messageObject.put("message", emojiEditText.getText().toString());
messageObject.put("toUserId", userId);
apiHelper.apiService.postPrivateMessage(messageObject)
.compose(apiHelper.configureApiCallObserver())
apiClient.postPrivateMessage(messageObject)
.subscribe(postChatMessageResult -> {
UiUtils.showSnackbar(FullProfileActivity.this, FullProfileActivity.this.fullprofile_scrollview,
String.format(getString(R.string.profile_message_sent_to), userName), UiUtils.SnackbarDisplayType.NORMAL);
@ -262,8 +262,8 @@ public class FullProfileActivity extends BaseActivity {
mountsTamedCount.setText(String.valueOf(user.getMountsTamedCount()));
// Load the members achievements now
apiHelper.apiService.GetMemberAchievements(this.userId)
.compose(apiHelper.configureApiCallObserver())
apiClient.GetMemberAchievements(this.userId)
.subscribe(this::fillAchievements,
throwable -> {
});

11
Habitica/src/main/java/com/habitrpg/android/habitica/ui/activities/IntroActivity.java
View file

@ -1,6 +1,6 @@
package com.habitrpg.android.habitica.ui.activities;
import com.habitrpg.android.habitica.APIHelper;
import com.magicmicky.habitrpgwrapper.lib.api.IApiClient;
import com.habitrpg.android.habitica.R;
import com.habitrpg.android.habitica.components.AppComponent;
import com.habitrpg.android.habitica.ui.fragments.setup.IntroFragment;
@ -22,7 +22,7 @@ import butterknife.BindView;
public class IntroActivity extends BaseActivity implements View.OnClickListener, ViewPager.OnPageChangeListener {
@Inject
public APIHelper apiHelper;
public IApiClient apiClient;
@BindView(R.id.view_pager)
ViewPager pager;
@BindView(R.id.view_pager_indicator)
@ -49,11 +49,8 @@ public class IntroActivity extends BaseActivity implements View.OnClickListener,
this.skipButton.setOnClickListener(this);
this.finishButton.setOnClickListener(this);
apiHelper.apiService.getContent(apiHelper.languageCode)
.compose(apiHelper.configureApiCallObserver())
.subscribe(contentResult -> {
}, throwable -> {
});
apiClient.getContent()
.subscribe(contentResult -> {}, throwable -> {});
}
@Override

20
Habitica/src/main/java/com/habitrpg/android/habitica/ui/activities/LoginActivity.java
View file

@ -14,7 +14,7 @@ import com.facebook.FacebookCallback;
import com.facebook.FacebookException;
import com.facebook.login.LoginResult;
import com.facebook.login.widget.LoginButton;
import com.habitrpg.android.habitica.APIHelper;
import com.magicmicky.habitrpgwrapper.lib.api.IApiClient;
import com.habitrpg.android.habitica.BuildConfig;
import com.habitrpg.android.habitica.R;
import com.habitrpg.android.habitica.callbacks.HabitRPGUserCallback;
@ -77,7 +77,7 @@ public class LoginActivity extends BaseActivity
@Inject
public APIHelper apiHelper;
public IApiClient apiClient;
@Inject
public SharedPreferences sharedPrefs;
public String mTmpUserToken;
@ -131,8 +131,7 @@ public class LoginActivity extends BaseActivity
@Override
public void onSuccess(LoginResult loginResult) {
AccessToken accessToken = AccessToken.getCurrentAccessToken();
apiHelper.connectSocial("facebook", accessToken.getUserId(), accessToken.getToken())
.compose(apiHelper.configureApiCallObserver())
apiClient.connectSocial("facebook", accessToken.getUserId(), accessToken.getToken())
.subscribe(LoginActivity.this, throwable -> {
hideProgress();
});
@ -193,8 +192,7 @@ public class LoginActivity extends BaseActivity
showValidationError(R.string.login_validation_error_fieldsmissing);
return;
}
apiHelper.registerUser(username,email,password, cpassword)
.compose(apiHelper.configureApiCallObserver())
apiClient.registerUser(username,email,password, cpassword)
.subscribe(LoginActivity.this, throwable -> {hideProgress();});
} else {
String username,password;
@ -204,8 +202,8 @@ public class LoginActivity extends BaseActivity
showValidationError(R.string.login_validation_error_fieldsmissing);
return;
}
apiHelper.connectUser(username,password)
.compose(apiHelper.configureApiCallObserver())
apiClient.connectUser(username,password)
.subscribe(LoginActivity.this, throwable -> {hideProgress();});
}
}
@ -343,7 +341,7 @@ public class LoginActivity extends BaseActivity
}
private void saveTokens(String api, String user) throws Exception {
this.apiHelper.updateAuthenticationCredentials(user, api);
this.apiClient.updateAuthenticationCredentials(user, api);
SharedPreferences.Editor editor = sharedPrefs.edit();
boolean ans = editor.putString(getString(R.string.SP_APIToken), api)
.putString(getString(R.string.SP_userID), user)
@ -421,8 +419,8 @@ public class LoginActivity extends BaseActivity
throw Exceptions.propagate(e);
}
})
.flatMap(token -> apiHelper.connectSocial("google", googleEmail, token))
.compose(apiHelper.configureApiCallObserver())
.flatMap(token -> apiClient.connectSocial("google", googleEmail, token))
.subscribe(LoginActivity.this, throwable -> {
hideProgress();
if (throwable.getCause() != null && GoogleAuthException.class.isAssignableFrom(throwable.getCause().getClass())) {

105
Habitica/src/main/java/com/habitrpg/android/habitica/ui/activities/MainActivity.java
View file

@ -1,7 +1,7 @@
package com.habitrpg.android.habitica.ui.activities;
import com.facebook.drawee.view.SimpleDraweeView;
import com.habitrpg.android.habitica.APIHelper;
import com.magicmicky.habitrpgwrapper.lib.api.IApiClient;
import com.habitrpg.android.habitica.HabiticaApplication;
import com.habitrpg.android.habitica.HostConfig;
import com.habitrpg.android.habitica.R;
@ -59,6 +59,7 @@ import com.habitrpg.android.habitica.widget.AvatarStatsWidgetProvider;
import com.habitrpg.android.habitica.widget.DailiesWidgetProvider;
import com.habitrpg.android.habitica.widget.HabitButtonWidgetProvider;
import com.habitrpg.android.habitica.widget.TodoListWidgetProvider;
import com.magicmicky.habitrpgwrapper.lib.api.IApiClient;
import com.magicmicky.habitrpgwrapper.lib.api.MaintenanceApiService;
import com.magicmicky.habitrpgwrapper.lib.models.HabitRPGUser;
import com.magicmicky.habitrpgwrapper.lib.models.Preferences;
@ -167,7 +168,7 @@ public class MainActivity extends BaseActivity implements Action1<Throwable>, Ha
public static final int GEM_PURCHASE_REQUEST = 111;
public static final int MIN_LEVEL_FOR_SKILLS = 11;
@Inject
public APIHelper apiHelper;
public IApiClient apiClient;
@Inject
public SoundManager soundManager;
@ -295,9 +296,8 @@ public class MainActivity extends BaseActivity implements Action1<Throwable>, Ha
//resync, if last sync was more than 10 minutes ago
if (this.lastSync == null || (new Date().getTime() - this.lastSync.getTime()) > 180000) {
if (this.apiHelper != null && this.apiHelper.hasAuthenticationKeys()) {
this.apiHelper.retrieveUser(true)
.compose(apiHelper.configureApiCallObserver())
if (this.apiClient != null && this.apiClient.hasAuthenticationKeys()) {
this.apiClient.retrieveUser(true)
.subscribe(new HabitRPGUserCallback(this), throwable -> {
});
this.checkMaintenance();
@ -403,7 +403,7 @@ public class MainActivity extends BaseActivity implements Action1<Throwable>, Ha
Preferences preferences = user.getPreferences();
if(preferences!= null) {
apiHelper.languageCode = preferences.getLanguage();
apiClient.setLanguageCode(preferences.getLanguage());
}
soundManager.setSoundTheme(preferences.getSound());
@ -414,7 +414,7 @@ public class MainActivity extends BaseActivity implements Action1<Throwable>, Ha
if (offset != user.getPreferences().getTimezoneOffset()) {
Map<String, Object> updateData = new HashMap<>();
updateData.put("preferences.timezoneOffset", String.valueOf(offset));
apiHelper.apiService.updateUser(updateData).compose(apiHelper.configureApiCallObserver())
apiClient.updateUser(updateData)
.subscribe(new MergeUserCallback(this, user), throwable -> {
});
}
@ -911,15 +911,15 @@ public class MainActivity extends BaseActivity implements Action1<Throwable>, Ha
@Override
public void onActivityResult(int requestCode, int resultCode, Intent data) {
if (resultCode == SELECT_CLASS_RESULT) {
if (this.apiHelper != null) {
this.apiHelper.retrieveUser(true)
.compose(apiHelper.configureApiCallObserver())
if (this.apiClient != null) {
this.apiClient.retrieveUser(true)
.subscribe(new HabitRPGUserCallback(this), throwable -> {
});
}
} else if (requestCode == GEM_PURCHASE_REQUEST) {
this.apiHelper.retrieveUser(true)
.compose(apiHelper.configureApiCallObserver())
this.apiClient.retrieveUser(true)
.subscribe(new HabitRPGUserCallback(this), throwable -> {
});
}
@ -941,16 +941,15 @@ public class MainActivity extends BaseActivity implements Action1<Throwable>, Ha
@Subscribe
public void onEvent(UpdateUserCommand event) {
apiHelper.apiService.updateUser(event.updateData).compose(apiHelper.configureApiCallObserver())
apiClient.updateUser(event.updateData)
.subscribe(new MergeUserCallback(this, user), throwable -> {
});
}
@Subscribe
public void onEvent(EquipCommand event) {
this.apiHelper.apiService.equipItem(event.type, event.key)
.compose(apiHelper.configureApiCallObserver())
.subscribe(new ItemsCallback(this, this.user), throwable -> {
this.apiClient.equipItem(event.type, event.key)
.subscribe(new ItemsCallback(this, this.user), throwable -> {
});
}
@ -958,8 +957,8 @@ public class MainActivity extends BaseActivity implements Action1<Throwable>, Ha
public void onEvent(UnlockPathCommand event) {
this.user.setBalance(this.user.getBalance() - event.balanceDiff);
this.setUserData(false);
apiHelper.apiService.unlockPath(event.path)
.compose(apiHelper.configureApiCallObserver())
apiClient.unlockPath(event.path)
.subscribe(new UnlockCallback(this, this.user), throwable -> {
});
}
@ -972,26 +971,26 @@ public class MainActivity extends BaseActivity implements Action1<Throwable>, Ha
@Subscribe
public void onEvent(final BuyGemItemCommand event) {
if (event.item.canBuy(user) || !event.item.getCurrency().equals("gems")) {
Observable<HabitResponse<Void>> observable;
Observable<Void> observable;
if (event.shopIdentifier.equals(Shop.TIME_TRAVELERS_SHOP)) {
if (event.item.purchaseType.equals("gear")) {
observable = apiHelper.apiService.purchaseMysterySet(event.item.categoryIdentifier);
observable = apiClient.purchaseMysterySet(event.item.categoryIdentifier);
} else {
observable = apiHelper.apiService.purchaseHourglassItem(event.item.purchaseType, event.item.key);
observable = apiClient.purchaseHourglassItem(event.item.purchaseType, event.item.key);
}
} else if (event.item.purchaseType.equals("quests") && event.item.getCurrency().equals("gold")) {
observable = apiHelper.apiService.purchaseQuest(event.item.key);
observable = apiClient.purchaseQuest(event.item.key);
} else {
observable = apiHelper.apiService.purchaseItem(event.item.purchaseType, event.item.key);
observable = apiClient.purchaseItem(event.item.purchaseType, event.item.key);
}
observable
.compose(apiHelper.configureApiCallObserver())
.doOnNext(aVoid -> {
showSnackbar(this, floatingMenuWrapper, getString(R.string.successful_purchase, event.item.text), SnackbarDisplayType.NORMAL);
})
.subscribe(buyResponse -> {
apiHelper.retrieveUser(false)
.compose(apiHelper.configureApiCallObserver())
apiClient.retrieveUser(false)
.subscribe(new HabitRPGUserCallback(this), throwable -> {
});
}, throwable -> {
@ -1025,8 +1024,7 @@ public class MainActivity extends BaseActivity implements Action1<Throwable>, Ha
}
if (event.Reward.specialTag != null && event.Reward.specialTag.equals("item")) {
apiHelper.apiService.buyItem(event.Reward.getId())
.compose(apiHelper.configureApiCallObserver())
apiClient.buyItem(event.Reward.getId())
.subscribe(buyResponse -> {
String snackbarMessage = getString(R.string.successful_purchase, event.Reward.getText());
@ -1070,8 +1068,8 @@ public class MainActivity extends BaseActivity implements Action1<Throwable>, Ha
} else {
soundManager.loadAndPlayAudio(SoundManager.SoundReward);
// user created Rewards
apiHelper.apiService.postTaskDirection(rewardKey, TaskDirection.down.toString())
.compose(apiHelper.configureApiCallObserver())
apiClient.postTaskDirection(rewardKey, TaskDirection.down.toString())
.subscribe(new TaskScoringCallback(this, rewardKey), throwable -> {
});
}
@ -1087,7 +1085,7 @@ public class MainActivity extends BaseActivity implements Action1<Throwable>, Ha
@Subscribe
public void onEvent(final DeleteTaskCommand cmd) {
apiHelper.apiService.deleteTask(cmd.TaskIdToDelete).compose(apiHelper.configureApiCallObserver())
apiClient.deleteTask(cmd.TaskIdToDelete)
.subscribe(aVoid -> {
EventBus.getDefault().post(new TaskRemovedEvent(cmd.TaskIdToDelete));
}, throwable -> {
@ -1111,8 +1109,8 @@ public class MainActivity extends BaseActivity implements Action1<Throwable>, Ha
@Subscribe
public void onEvent(SellItemCommand event) {
this.apiHelper.apiService.sellItem(event.item.getType(), event.item.getKey())
.compose(apiHelper.configureApiCallObserver())
this.apiClient.sellItem(event.item.getType(), event.item.getKey())
.subscribe(habitRPGUser -> {
user.setItems(habitRPGUser.getItems());
user.save();
@ -1127,8 +1125,8 @@ public class MainActivity extends BaseActivity implements Action1<Throwable>, Ha
if (event.usingEgg == null || event.usingHatchingPotion == null) {
return;
}
this.apiHelper.apiService.hatchPet(event.usingEgg.getKey(), event.usingHatchingPotion.getKey())
.compose(apiHelper.configureApiCallObserver())
this.apiClient.hatchPet(event.usingEgg.getKey(), event.usingHatchingPotion.getKey())
.subscribe(new ItemsCallback(user1 -> {
FrameLayout petWrapper = (FrameLayout) getLayoutInflater().inflate(R.layout.pet_imageview, null);
SimpleDraweeView petImageView = (SimpleDraweeView) petWrapper.findViewById(R.id.pet_imageview);
@ -1165,8 +1163,8 @@ public class MainActivity extends BaseActivity implements Action1<Throwable>, Ha
return;
}
final Pet pet = event.usingPet;
this.apiHelper.apiService.feedPet(event.usingPet.getKey(), event.usingFood.getKey())
.compose(apiHelper.configureApiCallObserver())
this.apiClient.feedPet(event.usingPet.getKey(), event.usingFood.getKey())
.subscribe(feedResponse -> {
MainActivity.this.user.getItems().getPets().put(pet.getKey(), feedResponse.value);
MainActivity.this.user.getItems().getFood().put(event.usingFood.getKey(), event.usingFood.getOwned() - 1);
@ -1209,8 +1207,7 @@ public class MainActivity extends BaseActivity implements Action1<Throwable>, Ha
public void reloadContent(ReloadContentEvent event) {
if (!this.isloadingContent) {
this.isloadingContent = true;
this.apiHelper.apiService.getContent(apiHelper.languageCode)
.compose(apiHelper.configureApiCallObserver())
this.apiClient.getContent()
.subscribe(contentResult -> {
isloadingContent = false;
ContentReloadedEvent event1 = new ContentReloadedEvent();
@ -1253,8 +1250,8 @@ public class MainActivity extends BaseActivity implements Action1<Throwable>, Ha
if (lvl > user.getStats().getLvl()) {
displayLevelUpDialog(lvl);
this.apiHelper.retrieveUser(true)
.compose(apiHelper.configureApiCallObserver())
this.apiClient.retrieveUser(true)
.subscribe(new HabitRPGUserCallback(this), throwable -> {
});
user.getStats().setLvl(lvl);
@ -1314,8 +1311,8 @@ public class MainActivity extends BaseActivity implements Action1<Throwable>, Ha
.setView(customView)
.setPositiveButton(R.string.faint_button, (dialog, which) -> {
faintDialog = null;
apiHelper.apiService.revive()
.compose(apiHelper.configureApiCallObserver())
apiClient.revive()
.subscribe(new MergeUserCallback(MainActivity.this, MainActivity.this.user), throwable -> {
});
})
@ -1430,8 +1427,8 @@ public class MainActivity extends BaseActivity implements Action1<Throwable>, Ha
String path = "flags.tutorial." + step.getTutorialGroup() + "." + step.getIdentifier();
Map<String, Object> updateData = new HashMap<>();
updateData.put(path, true);
apiHelper.apiService.updateUser(updateData)
.compose(apiHelper.configureApiCallObserver())
apiClient.updateUser(updateData)
.subscribe(new MergeUserCallback(this, user), throwable -> {
});
this.overlayFrameLayout.removeView(this.activeTutorialView);
@ -1485,8 +1482,8 @@ public class MainActivity extends BaseActivity implements Action1<Throwable>, Ha
@Subscribe
public void onEvent(TaskCheckedCommand event) {
apiHelper.apiService.postTaskDirection(event.Task.getId(), (event.Task.getCompleted() ? TaskDirection.down : TaskDirection.up).toString())
.compose(apiHelper.configureApiCallObserver())
apiClient.postTaskDirection(event.Task.getId(), (event.Task.getCompleted() ? TaskDirection.down : TaskDirection.up).toString())
.subscribe(new TaskScoringCallback(this, event.Task.getId()), throwable -> {
event.Task.completed = !event.Task.completed;
event.Task.save();
@ -1505,8 +1502,8 @@ public class MainActivity extends BaseActivity implements Action1<Throwable>, Ha
@Subscribe
public void onEvent(ChecklistCheckedCommand event) {
apiHelper.apiService.scoreChecklistItem(event.task.getId(), event.item.getId())
.compose(apiHelper.configureApiCallObserver())
apiClient.scoreChecklistItem(event.task.getId(), event.item.getId())
.subscribe(new TaskUpdateCallback(), throwable -> {
});
}
@ -1526,13 +1523,13 @@ public class MainActivity extends BaseActivity implements Action1<Throwable>, Ha
public void onEvent(final TaskSaveEvent event) {
Task task = event.task;
if (event.created) {
this.apiHelper.apiService.createItem(task)
.compose(apiHelper.configureApiCallObserver())
this.apiClient.createItem(task)
.subscribe(new TaskCreationCallback(), throwable -> {
});
} else {
this.apiHelper.apiService.updateTask(task.getId(), task)
.compose(apiHelper.configureApiCallObserver())
this.apiClient.updateTask(task.getId(), task)
.subscribe(new TaskUpdateCallback(), throwable -> {
});
}
@ -1540,7 +1537,7 @@ public class MainActivity extends BaseActivity implements Action1<Throwable>, Ha
private void checkMaintenance() {
this.maintenanceService.getMaintenanceStatus()
.compose(apiHelper.configureApiCallObserver())
.compose(apiClient.configureApiCallObserver())
.subscribe(maintenanceResponse -> {
if (maintenanceResponse.activeMaintenance) {
Intent intent = createMaintenanceIntent(maintenanceResponse, false);

8
Habitica/src/main/java/com/habitrpg/android/habitica/ui/activities/MaintenanceActivity.java
View file

@ -1,7 +1,7 @@
package com.habitrpg.android.habitica.ui.activities;
import com.facebook.drawee.view.SimpleDraweeView;
import com.habitrpg.android.habitica.APIHelper;
import com.magicmicky.habitrpgwrapper.lib.api.IApiClient;
import com.habitrpg.android.habitica.R;
import com.habitrpg.android.habitica.components.AppComponent;
import com.habitrpg.android.habitica.ui.helpers.MarkdownParser;
@ -21,8 +21,6 @@ import javax.inject.Inject;
import butterknife.BindView;
import butterknife.OnClick;
import rx.android.schedulers.AndroidSchedulers;
import rx.schedulers.Schedulers;
public class MaintenanceActivity extends BaseActivity {
@ -30,7 +28,7 @@ public class MaintenanceActivity extends BaseActivity {
public MaintenanceApiService maintenanceService;
@Inject
public APIHelper apiHelper;
public IApiClient apiClient;
@BindView(R.id.titleTextView)
TextView titleTextView;
@ -77,7 +75,7 @@ public class MaintenanceActivity extends BaseActivity {
super.onResume();
if (!isDeprecationNotice) {
this.maintenanceService.getMaintenanceStatus()
.compose(apiHelper.configureApiCallObserver())
.compose(apiClient.configureApiCallObserver())
.subscribe(maintenanceResponse -> {
if (!maintenanceResponse.activeMaintenance) {
finish();

14
Habitica/src/main/java/com/habitrpg/android/habitica/ui/activities/PartyInviteActivity.java
View file

@ -1,9 +1,8 @@
package com.habitrpg.android.habitica.ui.activities;
import com.habitrpg.android.habitica.APIHelper;
import com.magicmicky.habitrpgwrapper.lib.api.IApiClient;
import com.habitrpg.android.habitica.HostConfig;
import com.habitrpg.android.habitica.R;
import com.habitrpg.android.habitica.callbacks.HabitRPGUserCallback;
import com.habitrpg.android.habitica.components.AppComponent;
import com.habitrpg.android.habitica.prefs.scanner.IntentIntegrator;
import com.habitrpg.android.habitica.prefs.scanner.IntentResult;
@ -22,13 +21,11 @@ import android.support.design.widget.TabLayout;
import android.support.v4.app.Fragment;
import android.support.v4.app.FragmentPagerAdapter;
import android.support.v4.view.ViewPager;
import android.util.Log;
import android.view.Menu;
import android.view.MenuItem;
import android.widget.Toast;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@ -48,7 +45,7 @@ public class PartyInviteActivity extends BaseActivity {
private String userIdToInvite;
@Inject
APIHelper apiHelper;
IApiClient apiClient;
@Inject
protected HostConfig hostConfig;
@ -210,10 +207,7 @@ public class PartyInviteActivity extends BaseActivity {
invites.add(userIdToInvite);
inviteData.put("uuids", invites);
this.apiHelper.apiService.inviteToGroup(this.user.getParty().getId(), inviteData)
.compose(apiHelper.configureApiCallObserver())
.subscribe(aVoid -> {
}, throwable -> {
});
this.apiClient.inviteToGroup(this.user.getParty().getId(), inviteData)
.subscribe(aVoid -> {}, throwable -> {});
}
}

22
Habitica/src/main/java/com/habitrpg/android/habitica/ui/activities/SetupActivity.java
View file

@ -10,8 +10,7 @@ import android.support.v7.preference.PreferenceManager;
import android.view.View;
import android.widget.Button;
import com.amplitude.api.Amplitude;
import com.habitrpg.android.habitica.APIHelper;
import com.magicmicky.habitrpgwrapper.lib.api.IApiClient;
import com.habitrpg.android.habitica.HostConfig;
import com.habitrpg.android.habitica.R;
import com.habitrpg.android.habitica.callbacks.HabitRPGUserCallback;
@ -28,15 +27,12 @@ import com.raizlabs.android.dbflow.sql.language.Select;
import org.greenrobot.eventbus.EventBus;
import org.greenrobot.eventbus.Subscribe;
import org.json.JSONException;
import org.json.JSONObject;
import java.util.Calendar;
import java.util.HashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Objects;
import javax.inject.Inject;
@ -45,7 +41,7 @@ import butterknife.BindView;
public class SetupActivity extends BaseActivity implements View.OnClickListener, ViewPager.OnPageChangeListener, HabitRPGUserCallback.OnUserReceived {
@Inject
public APIHelper apiHelper;
public IApiClient apiClient;
@Inject
protected HostConfig hostConfig;
@BindView(R.id.view_pager)
@ -83,8 +79,7 @@ public class SetupActivity extends BaseActivity implements View.OnClickListener,
String currentDeviceLanguage = Locale.getDefault().getLanguage();
for (String language : getResources().getStringArray(R.array.LanguageValues)) {
if (language.equals(currentDeviceLanguage)) {
apiHelper.apiService.registrationLanguage(currentDeviceLanguage)
.compose(apiHelper.configureApiCallObserver())
apiClient.registrationLanguage(currentDeviceLanguage)
.subscribe(new MergeUserCallback(this, user), throwable -> {
});
}
@ -105,8 +100,7 @@ public class SetupActivity extends BaseActivity implements View.OnClickListener,
if (this.user != null) {
setupViewpager();
} else {
this.apiHelper.apiService.getUser()
.compose(this.apiHelper.configureApiCallObserver())
this.apiClient.getUser()
.subscribe(new HabitRPGUserCallback(this), throwable -> {
});
}
@ -152,8 +146,7 @@ public class SetupActivity extends BaseActivity implements View.OnClickListener,
@Subscribe
public void onEvent(UpdateUserCommand event) {
this.apiHelper.apiService.updateUser(event.updateData)
.compose(this.apiHelper.configureApiCallObserver())
this.apiClient.updateUser(event.updateData)
.subscribe(new MergeUserCallback(this, user), throwable -> {
});
}
@ -169,13 +162,12 @@ public class SetupActivity extends BaseActivity implements View.OnClickListener,
if (this.pager.getCurrentItem() == 1) {
List<Task> newTasks = this.taskSetupFragment.createSampleTasks();
this.completedSetup = true;
this.apiHelper.apiService.createTasks(newTasks)
.compose(this.apiHelper.configureApiCallObserver())
this.apiClient.createTasks(newTasks)
.subscribe(tasks -> {
onUserReceived(user);
}, throwable -> {
});
//this.apiHelper.apiService.batchOperation(operations, new HabitRPGUserCallback(this));
//this.apiClient.batchOperation(operations, new HabitRPGUserCallback(this));
}
this.pager.setCurrentItem(this.pager.getCurrentItem() + 1);
} else if (v == this.previousButton) {

13
Habitica/src/main/java/com/habitrpg/android/habitica/ui/activities/SkillMemberActivity.java
View file

@ -6,7 +6,7 @@ import android.os.Bundle;
import android.support.v7.widget.LinearLayoutManager;
import android.support.v7.widget.RecyclerView;
import com.habitrpg.android.habitica.APIHelper;
import com.magicmicky.habitrpgwrapper.lib.api.IApiClient;
import com.habitrpg.android.habitica.R;
import com.habitrpg.android.habitica.components.AppComponent;
import com.habitrpg.android.habitica.events.commands.SelectMemberCommand;
@ -27,7 +27,7 @@ public class SkillMemberActivity extends BaseActivity {
RecyclerView recyclerView;
@Inject
public APIHelper apiHelper;
public IApiClient apiClient;
@Override
protected int getLayoutResId() {
@ -48,21 +48,18 @@ public class SkillMemberActivity extends BaseActivity {
}
private void loadMemberList() {
recyclerView.setLayoutManager(new LinearLayoutManager(this));
viewAdapter = new PartyMemberRecyclerViewAdapter();
viewAdapter.context = this;
recyclerView.setAdapter(viewAdapter);
apiHelper.apiService.getGroup("party")
.compose(this.apiHelper.configureApiCallObserver())
apiClient.getGroup("party")
.subscribe(group -> {
if (group == null) {
return;
}
apiHelper.apiService.getGroupMembers(group.id, true)
.compose(apiHelper.configureApiCallObserver())
apiClient.getGroupMembers(group.id, true)
.subscribe(members -> {
viewAdapter.setMemberList(members, true);
},
@ -74,7 +71,7 @@ public class SkillMemberActivity extends BaseActivity {
}
@Subscribe
public void onEvent(SelectMemberCommand evt){
public void onEvent(SelectMemberCommand evt) {
Intent resultIntent = new Intent();
resultIntent.putExtra("member_id", evt.MemberId);
setResult(Activity.RESULT_OK, resultIntent);

12
Habitica/src/main/java/com/habitrpg/android/habitica/ui/adapter/social/PublicGuildsRecyclerViewAdapter.java
View file

@ -1,6 +1,6 @@
package com.habitrpg.android.habitica.ui.adapter.social;
import com.habitrpg.android.habitica.APIHelper;
import com.magicmicky.habitrpgwrapper.lib.api.IApiClient;
import com.habitrpg.android.habitica.R;
import com.habitrpg.android.habitica.events.DisplayFragmentEvent;
import com.habitrpg.android.habitica.ui.fragments.social.GuildFragment;
@ -25,7 +25,7 @@ import butterknife.ButterKnife;
public class PublicGuildsRecyclerViewAdapter extends RecyclerView.Adapter<PublicGuildsRecyclerViewAdapter.GuildViewHolder> implements Filterable{
public APIHelper apiHelper;
public IApiClient apiClient;
private List<Group> publicGuildList;
private List<Group> fullPublicGuildList;
private List<String> memberGuildIDs;
@ -58,8 +58,8 @@ public class PublicGuildsRecyclerViewAdapter extends RecyclerView.Adapter<Public
Group guild = (Group) v.getTag();
boolean isMember = this.memberGuildIDs != null && this.memberGuildIDs.contains(guild.id);
if (isMember) {
PublicGuildsRecyclerViewAdapter.this.apiHelper.apiService.leaveGroup(guild.id)
.compose(apiHelper.configureApiCallObserver())
PublicGuildsRecyclerViewAdapter.this.apiClient.leaveGroup(guild.id)
.subscribe(aVoid -> {
memberGuildIDs.remove(guild.id);
int indexOfGroup = publicGuildList.indexOf(guild);
@ -67,8 +67,8 @@ public class PublicGuildsRecyclerViewAdapter extends RecyclerView.Adapter<Public
}, throwable -> {
});
} else {
PublicGuildsRecyclerViewAdapter.this.apiHelper.apiService.joinGroup(guild.id)
.compose(apiHelper.configureApiCallObserver())
PublicGuildsRecyclerViewAdapter.this.apiClient.joinGroup(guild.id)
.subscribe(group -> {
memberGuildIDs.add(group.id);
int indexOfGroup = publicGuildList.indexOf(group);

17
Habitica/src/main/java/com/habitrpg/android/habitica/ui/adapter/tasks/RewardsRecyclerViewAdapter.java
View file

@ -1,12 +1,13 @@
package com.habitrpg.android.habitica.ui.adapter.tasks;
import com.habitrpg.android.habitica.APIHelper;
import com.habitrpg.android.habitica.ContentCache;
import com.habitrpg.android.habitica.HabiticaBaseApplication;
import com.habitrpg.android.habitica.R;
import com.habitrpg.android.habitica.components.AppComponent;
import com.habitrpg.android.habitica.helpers.TagsHelper;
import com.habitrpg.android.habitica.ui.viewHolders.tasks.RewardViewHolder;
import com.magicmicky.habitrpgwrapper.lib.api.IApiClient;
import com.magicmicky.habitrpgwrapper.lib.models.HabitRPGUser;
import com.magicmicky.habitrpgwrapper.lib.models.tasks.ItemData;
import com.magicmicky.habitrpgwrapper.lib.models.tasks.Task;
@ -25,13 +26,13 @@ public class RewardsRecyclerViewAdapter extends BaseTasksRecyclerViewAdapter<Rew
private final ContentCache contentCache;
private final HabitRPGUser user;
private APIHelper apiHelper;
private IApiClient apiClient;
public RewardsRecyclerViewAdapter(String taskType, TagsHelper tagsHelper, int layoutResource, Context newContext, HabitRPGUser user, APIHelper apiHelper) {
public RewardsRecyclerViewAdapter(String taskType, TagsHelper tagsHelper, int layoutResource, Context newContext, HabitRPGUser user, IApiClient apiClient) {
super(taskType, tagsHelper, layoutResource, newContext, user.getId());
this.user = user;
this.apiHelper = apiHelper;
this.contentCache = new ContentCache(apiHelper);
this.apiClient = apiClient;
this.contentCache = new ContentCache(apiClient);
}
@Override
@ -40,9 +41,9 @@ public class RewardsRecyclerViewAdapter extends BaseTasksRecyclerViewAdapter<Rew
}
public void loadEquipmentRewards() {
if (apiHelper != null) {
apiHelper.apiService.getInventoryBuyableGear()
.compose(apiHelper.configureApiCallObserver())
if (apiClient != null) {
apiClient.getInventoryBuyableGear()
.flatMap(items -> {
// get itemdata list
ArrayList<String> itemKeys = new ArrayList<>();

5
Habitica/src/main/java/com/habitrpg/android/habitica/ui/fragments/BaseMainFragment.java
View file

@ -8,9 +8,10 @@ import android.view.View;
import android.view.ViewGroup;
import android.widget.FrameLayout;
import com.habitrpg.android.habitica.APIHelper;
import com.magicmicky.habitrpgwrapper.lib.api.IApiClient;
import com.habitrpg.android.habitica.helpers.SoundManager;
import com.habitrpg.android.habitica.ui.activities.MainActivity;
import com.magicmicky.habitrpgwrapper.lib.api.IApiClient;
import com.magicmicky.habitrpgwrapper.lib.models.HabitRPGUser;
import com.raizlabs.android.dbflow.sql.builder.Condition;
import com.raizlabs.android.dbflow.sql.language.Select;
@ -20,7 +21,7 @@ import javax.inject.Inject;
public abstract class BaseMainFragment extends BaseFragment {
@Inject
public APIHelper apiHelper;
public IApiClient apiClient;
@Inject
protected SoundManager soundManager;

13
Habitica/src/main/java/com/habitrpg/android/habitica/ui/fragments/inventory/customization/AvatarOverviewFragment.java
View file

@ -60,14 +60,10 @@ public class AvatarOverviewFragment extends BaseMainFragment implements AdapterV
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
if (this.apiHelper != null) {
this.apiHelper.apiService.getContent(apiHelper.languageCode)
.compose(apiHelper.configureApiCallObserver())
.subscribe(contentResult -> {
}, throwable -> {
});
if (apiClient != null) {
apiClient.getContent()
.subscribe(contentResult -> {}, throwable -> {});
}
}
@Override
@ -142,8 +138,7 @@ public class AvatarOverviewFragment extends BaseMainFragment implements AdapterV
if (!this.user.getPreferences().getSize().equals(newSize)) {
Map<String, Object> updateData = new HashMap<>();
updateData.put("preferences.size", newSize);
apiHelper.apiService.updateUser(updateData)
.compose(apiHelper.configureApiCallObserver())
apiClient.updateUser(updateData)
.subscribe(new MergeUserCallback(activity, user), throwable -> {
});
}

4
Habitica/src/main/java/com/habitrpg/android/habitica/ui/fragments/inventory/items/ItemsFragment.java
View file

@ -106,8 +106,8 @@ public class ItemsFragment extends BaseMainFragment {
@Subscribe
public void onEvent(InvitePartyToQuestCommand event) {
this.apiHelper.apiService.inviteToQuest("party", event.questKey)
.compose(apiHelper.configureApiCallObserver())
this.apiClient.inviteToQuest("party", event.questKey)
.subscribe(group -> {
OpenMenuItemCommand event1 = new OpenMenuItemCommand();
event1.identifier = MainDrawerBuilder.SIDEBAR_PARTY;

7
Habitica/src/main/java/com/habitrpg/android/habitica/ui/fragments/inventory/shops/ShopFragment.java
View file

@ -1,6 +1,6 @@
package com.habitrpg.android.habitica.ui.fragments.inventory.shops;
import com.habitrpg.android.habitica.APIHelper;
import com.magicmicky.habitrpgwrapper.lib.api.IApiClient;
import com.habitrpg.android.habitica.R;
import com.habitrpg.android.habitica.components.AppComponent;
import com.habitrpg.android.habitica.ui.adapter.inventory.ShopRecyclerAdapter;
@ -40,7 +40,7 @@ public class ShopFragment extends BaseFragment {
public Shop shop;
@Inject
APIHelper apiHelper;
IApiClient apiClient;
@Nullable
@Override
@ -100,8 +100,7 @@ public class ShopFragment extends BaseFragment {
shopUrl = "seasonal";
break;
}
this.apiHelper.apiService.fetchShopInventory(shopUrl)
.compose(this.apiHelper.configureApiCallObserver())
this.apiClient.fetchShopInventory(shopUrl)
.subscribe(shop -> {
this.shop = shop;
this.adapter.setShop(shop);

19
Habitica/src/main/java/com/habitrpg/android/habitica/ui/fragments/preferences/PreferencesFragment.java
View file

@ -10,7 +10,7 @@ import android.support.v7.app.AlertDialog;
import android.support.v7.preference.Preference;
import android.support.v7.preference.PreferenceScreen;
import com.habitrpg.android.habitica.APIHelper;
import com.magicmicky.habitrpgwrapper.lib.api.IApiClient;
import com.habitrpg.android.habitica.HabiticaApplication;
import com.habitrpg.android.habitica.R;
import com.habitrpg.android.habitica.callbacks.MergeUserCallback;
@ -41,7 +41,7 @@ public class PreferencesFragment extends BasePreferencesFragment implements
SharedPreferences.OnSharedPreferenceChangeListener {
@Inject
public APIHelper apiHelper;
public IApiClient apiClient;
@Inject
public SoundManager soundManager;
private Context context;
@ -185,8 +185,7 @@ public class PreferencesFragment extends BasePreferencesFragment implements
int hour = Integer.parseInt(pieces[0]);
Map<String, Object> updateObject = new HashMap<>();
updateObject.put("dayStart", hour);
apiHelper.apiService.changeCustomDayStart(updateObject)
.compose(apiHelper.configureApiCallObserver())
apiClient.changeCustomDayStart(updateObject)
.subscribe(user -> {}, throwable -> {});
} else if (key.equals("language")) {
LanguageHelper languageHelper = new LanguageHelper(sharedPreferences.getString(key,"en"));
@ -203,16 +202,15 @@ public class PreferencesFragment extends BasePreferencesFragment implements
Map<String, Object> updateData = new HashMap<>();
updateData.put("preferences.language", languageHelper.getLanguageCode());
apiHelper.apiService.updateUser(updateData)
.compose(apiHelper.configureApiCallObserver())
apiClient.updateUser(updateData)
.subscribe(new MergeUserCallback(activity, user), throwable -> {
});
Preferences preferences = user.getPreferences();
preferences.setLanguage(languageHelper.getLanguageCode());
apiHelper.languageCode = preferences.getLanguage();
apiHelper.apiService.getContent(apiHelper.languageCode)
.compose(apiHelper.configureApiCallObserver())
apiClient.setLanguageCode(preferences.getLanguage());
apiClient.getContent()
.subscribe(contentResult -> {
}, throwable -> {
});
@ -234,8 +232,7 @@ public class PreferencesFragment extends BasePreferencesFragment implements
Map<String, Object> updateData = new HashMap<>();
updateData.put("preferences.sound", newAudioTheme);
MergeUserCallback mergeUserCallback = new MergeUserCallback(activity, user);
apiHelper.apiService.updateUser(updateData)
.compose(apiHelper.configureApiCallObserver())
apiClient.updateUser(updateData)
.subscribe(mergeUserCallback, throwable -> {
});

6
Habitica/src/main/java/com/habitrpg/android/habitica/ui/fragments/setup/AvatarSetupFragment.java
View file

@ -1,6 +1,6 @@
package com.habitrpg.android.habitica.ui.fragments.setup;
import com.habitrpg.android.habitica.APIHelper;
import com.magicmicky.habitrpgwrapper.lib.api.IApiClient;
import com.habitrpg.android.habitica.R;
import com.habitrpg.android.habitica.components.AppComponent;
import com.habitrpg.android.habitica.ui.AvatarView;
@ -43,7 +43,7 @@ public class AvatarSetupFragment extends BaseFragment {
private HabitRPGUser user;
@Inject
APIHelper apiHelper;
IApiClient apiClient;
@Nullable
@Override
@ -108,7 +108,7 @@ public class AvatarSetupFragment extends BaseFragment {
List<Customization> customizations = select.queryList();
if (customizations.size() == 0) {
this.apiHelper.getContent().compose(this.apiHelper.configureApiCallObserver())
this.apiClient.getContent()
.subscribe(contentResult -> {
this.loadCustomizations();
}, throwable -> {});

12
Habitica/src/main/java/com/habitrpg/android/habitica/ui/fragments/skills/SkillsFragment.java
View file

@ -175,8 +175,8 @@ public class SkillsFragment extends BaseMainFragment {
message.append(" + ").append(round(event.gold, 2)).append(" GP");
}
UiUtils.showSnackbar(activity, activity.getFloatingMenuWrapper(), message.toString(), UiUtils.SnackbarDisplayType.NORMAL);
apiHelper.apiService.getUser()
.compose(apiHelper.configureApiCallObserver())
apiClient.getUser()
.subscribe(new MergeUserCallback(activity, user), throwable -> {
});
}
@ -206,13 +206,13 @@ public class SkillsFragment extends BaseMainFragment {
private void useSkill(Skill skill, String taskId) {
displayProgressDialog();
Observable<HabitResponse<SkillResponse>> observable;
Observable<SkillResponse> observable;
if (taskId != null) {
observable = apiHelper.apiService.useSkill(skill.key, skill.target, taskId);
observable = apiClient.useSkill(skill.key, skill.target, taskId);
} else {
observable = apiHelper.apiService.useSkill(skill.key, skill.target);
observable = apiClient.useSkill(skill.key, skill.target);
}
observable.compose(apiHelper.configureApiCallObserver())
observable
.subscribe(new SkillCallback(activity, user, skill), throwable -> {
removeProgressDialog();
});

26
Habitica/src/main/java/com/habitrpg/android/habitica/ui/fragments/social/ChatListFragment.java
View file

@ -1,6 +1,6 @@
package com.habitrpg.android.habitica.ui.fragments.social;
import com.habitrpg.android.habitica.APIHelper;
import com.magicmicky.habitrpgwrapper.lib.api.IApiClient;
import com.habitrpg.android.habitica.HabiticaApplication;
import com.habitrpg.android.habitica.R;
import com.habitrpg.android.habitica.components.AppComponent;
@ -37,7 +37,6 @@ import android.support.v7.widget.RecyclerView;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.Toast;
import java.util.ArrayList;
import java.util.HashMap;
@ -53,7 +52,7 @@ public class ChatListFragment extends BaseFragment implements SwipeRefreshLayout
public String seenGroupId;
@Inject
public APIHelper apiHelper;
public IApiClient apiClient;
public boolean isTavern;
@BindView(R.id.chat_list)
RecyclerView mRecyclerView;
@ -138,7 +137,7 @@ public class ChatListFragment extends BaseFragment implements SwipeRefreshLayout
public void onRefresh() {
swipeRefreshLayout.setRefreshing(true);
apiHelper.apiService.listGroupChat(groupId).compose(apiHelper.configureApiCallObserver())
apiClient.listGroupChat(groupId)
.subscribe(this, throwable -> {
});
}
@ -156,8 +155,7 @@ public class ChatListFragment extends BaseFragment implements SwipeRefreshLayout
gotNewMessages = false;
apiHelper.apiService.seenMessages(seenGroupId)
.compose(apiHelper.configureApiCallObserver())
apiClient.seenMessages(seenGroupId)
.subscribe(s -> {
}, throwable -> {
});
@ -179,8 +177,8 @@ public class ChatListFragment extends BaseFragment implements SwipeRefreshLayout
AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
builder.setMessage(R.string.chat_flag_confirmation)
.setPositiveButton(R.string.flag_confirm, (dialog, id) -> {
apiHelper.apiService.flagMessage(cmd.groupId, cmd.chatMessage.id)
.compose(apiHelper.configureApiCallObserver())
apiClient.flagMessage(cmd.groupId, cmd.chatMessage.id)
.subscribe(aVoid -> {
MainActivity activity = (MainActivity) getActivity();
UiUtils.showSnackbar(activity, activity.getFloatingMenuWrapper(), "Flagged message by " + cmd.chatMessage.user, UiUtils.SnackbarDisplayType.NORMAL);
@ -194,7 +192,7 @@ public class ChatListFragment extends BaseFragment implements SwipeRefreshLayout
@Subscribe
public void onEvent(final ToggleLikeMessageCommand cmd) {
apiHelper.apiService.likeMessage(cmd.groupId, cmd.chatMessage.id).compose(apiHelper.configureApiCallObserver())
apiClient.likeMessage(cmd.groupId, cmd.chatMessage.id)
.subscribe(voids -> {
}, throwable -> {
});
@ -202,8 +200,8 @@ public class ChatListFragment extends BaseFragment implements SwipeRefreshLayout
@Subscribe
public void onEvent(final DeleteChatMessageCommand cmd) {
apiHelper.apiService.deleteMessage(cmd.groupId, cmd.chatMessage.id)
.compose(apiHelper.configureApiCallObserver())
apiClient.deleteMessage(cmd.groupId, cmd.chatMessage.id)
.subscribe(aVoid -> {
if (currentChatMessages != null) {
currentChatMessages.remove(cmd.chatMessage);
@ -218,8 +216,8 @@ public class ChatListFragment extends BaseFragment implements SwipeRefreshLayout
public void onEvent(SendNewGroupMessageCommand cmd) {
HashMap<String, String> messageObject = new HashMap<>();
messageObject.put("message", cmd.Message);
apiHelper.apiService.postGroupChat(cmd.TargetGroupId, messageObject)
.compose(apiHelper.configureApiCallObserver())
apiClient.postGroupChat(cmd.TargetGroupId, messageObject)
.subscribe(postChatMessageResult -> {
if (currentChatMessages != null) {
currentChatMessages.add(0, postChatMessageResult.message);
@ -235,7 +233,7 @@ public class ChatListFragment extends BaseFragment implements SwipeRefreshLayout
// If the ChatList is Tavern, we're able to toggle the sleep-mode
@Subscribe
public void onEvent(ToggleInnCommand event) {
apiHelper.apiService.sleep().compose(apiHelper.configureApiCallObserver())
apiClient.sleep()
.subscribe(aVoid -> {
ToggledInnStateEvent innState = new ToggledInnStateEvent();
innState.Inn = !user.getPreferences().getSleep();

36
Habitica/src/main/java/com/habitrpg/android/habitica/ui/fragments/social/GroupInformationFragment.java
View file

@ -1,6 +1,6 @@
package com.habitrpg.android.habitica.ui.fragments.social;
import com.habitrpg.android.habitica.APIHelper;
import com.magicmicky.habitrpgwrapper.lib.api.IApiClient;
import com.habitrpg.android.habitica.R;
import com.habitrpg.android.habitica.components.AppComponent;
import com.habitrpg.android.habitica.databinding.FragmentGroupInfoBinding;
@ -39,7 +39,7 @@ public class GroupInformationFragment extends BaseFragment {
FragmentGroupInfoBinding viewBinding;
@Inject
APIHelper apiHelper;
IApiClient apiClient;
@BindView(R.id.questMemberView)
LinearLayout questMemberView;
@ -215,8 +215,8 @@ public class GroupInformationFragment extends BaseFragment {
@OnClick(R.id.btnQuestAccept)
public void onQuestAccept() {
apiHelper.apiService.acceptQuest(group.id)
.compose(apiHelper.configureApiCallObserver())
apiClient.acceptQuest(group.id)
.subscribe(aVoid -> {
user.getParty().getQuest().RSVPNeeded = false;
group.quest.members.put(user.getId(), true);
@ -229,8 +229,8 @@ public class GroupInformationFragment extends BaseFragment {
@OnClick(R.id.btnQuestReject)
public void onQuestReject() {
apiHelper.apiService.rejectQuest(group.id)
.compose(apiHelper.configureApiCallObserver())
apiClient.rejectQuest(group.id)
.subscribe(aVoid -> {
user.getParty().getQuest().RSVPNeeded = false;
group.quest.members.put(user.getId(), false);
@ -246,8 +246,8 @@ public class GroupInformationFragment extends BaseFragment {
AlertDialog.Builder builder = new AlertDialog.Builder(getActivity())
.setMessage("Are you sure you want to leave the active quest? All your quest progress will be lost.")
.setPositiveButton("Yes", (dialog, which) -> {
apiHelper.apiService.leaveQuest(group.id)
.compose(apiHelper.configureApiCallObserver())
apiClient.leaveQuest(group.id)
.subscribe(aVoid -> {
group.quest.members.remove(user.getId());
setGroup(group);
@ -265,8 +265,8 @@ public class GroupInformationFragment extends BaseFragment {
AlertDialog.Builder builder = new AlertDialog.Builder(getActivity())
.setMessage(R.string.quest_begin_message)
.setPositiveButton(R.string.yes, (dialog, which) -> {
apiHelper.apiService.forceStartQuest(group.id, group)
.compose(apiHelper.configureApiCallObserver())
apiClient.forceStartQuest(group.id, group)
.subscribe(quest -> {
group.quest = quest;
setGroup(group);
@ -283,8 +283,8 @@ public class GroupInformationFragment extends BaseFragment {
AlertDialog.Builder builder = new AlertDialog.Builder(getActivity())
.setMessage(R.string.quest_cancel_message)
.setPositiveButton(R.string.yes, (dialog, which) -> {
apiHelper.apiService.cancelQuest(group.id)
.compose(apiHelper.configureApiCallObserver())
apiClient.cancelQuest(group.id)
.subscribe(aVoid -> {
setGroup(group);
setQuestContent(null);
@ -301,8 +301,8 @@ public class GroupInformationFragment extends BaseFragment {
AlertDialog.Builder builder = new AlertDialog.Builder(getActivity())
.setMessage("Are you sure you want to abort this mission? It will abort it for everyone in your party and all progress will be lost. The quest scroll will be returned to the quest owner.")
.setPositiveButton("Yes", (dialog, which) -> {
apiHelper.apiService.abortQuest(group.id)
.compose(apiHelper.configureApiCallObserver())
apiClient.abortQuest(group.id)
.subscribe(quest -> {
group.quest = quest;
setGroup(group);
@ -317,8 +317,8 @@ public class GroupInformationFragment extends BaseFragment {
@OnClick(R.id.btnPartyInviteAccept)
public void onPartyInviteAccepted() {
apiHelper.apiService.joinGroup(user.getInvitations().getParty().getId())
.compose(apiHelper.configureApiCallObserver())
apiClient.joinGroup(user.getInvitations().getParty().getId())
.subscribe(group -> {
setGroup(group);
viewBinding.setInvitation(null);
@ -327,8 +327,8 @@ public class GroupInformationFragment extends BaseFragment {
@OnClick(R.id.btnPartyInviteReject)
public void onPartyInviteRejected() {
apiHelper.apiService.rejectGroupInvite(user.getInvitations().getParty().getId())
.compose(apiHelper.configureApiCallObserver())
apiClient.rejectGroupInvite(user.getInvitations().getParty().getId())
.subscribe(aVoid -> {
viewBinding.setInvitation(null);
}, throwable -> {});

30
Habitica/src/main/java/com/habitrpg/android/habitica/ui/fragments/social/GuildFragment.java
View file

@ -34,12 +34,10 @@ public class GuildFragment extends BaseMainFragment implements Action1<Group> {
if (this.guildInformationFragment != null) {
this.guildInformationFragment.setGroup(guild);
}
if (this.guild.chat == null) {
if (this.apiHelper != null) {
apiHelper.apiService.getGroup(this.guild.id).compose(apiHelper.configureApiCallObserver())
.subscribe(this, throwable -> {
});
}
if (this.guild.chat == null && this.apiClient != null) {
apiClient.getGroup(this.guild.id)
.subscribe(this, throwable -> {
});
}
}
@ -67,8 +65,8 @@ public class GuildFragment extends BaseMainFragment implements Action1<Group> {
@Override
public void onViewCreated(View view, Bundle savedInstanceState) {
super.onViewCreated(view, savedInstanceState);
if (this.apiHelper != null && this.guild != null) {
apiHelper.apiService.getGroup(this.guild.id).compose(apiHelper.configureApiCallObserver())
if (this.apiClient != null && this.guild != null) {
apiClient.getGroup(this.guild.id)
.subscribe(this, throwable -> {
});
}
@ -94,13 +92,13 @@ public class GuildFragment extends BaseMainFragment implements Action1<Group> {
switch (id) {
case R.id.menu_guild_join:
this.apiHelper.apiService.joinGroup(this.guild.id).compose(apiHelper.configureApiCallObserver())
this.apiClient.joinGroup(this.guild.id)
.subscribe(this, throwable -> {
});
this.isMember = true;
return true;
case R.id.menu_guild_leave:
this.apiHelper.apiService.leaveGroup(this.guild.id).compose(apiHelper.configureApiCallObserver())
this.apiClient.leaveGroup(this.guild.id)
.subscribe(aVoid -> {
this.activity.supportInvalidateOptionsMenu();
}, throwable -> {
@ -224,8 +222,8 @@ public class GuildFragment extends BaseMainFragment implements Action1<Group> {
needsSaving = true;
}
if (needsSaving) {
this.apiHelper.apiService.updateGroup(this.guild.id, this.guild)
.compose(apiHelper.configureApiCallObserver())
this.apiClient.updateGroup(this.guild.id, this.guild)
.subscribe(aVoid -> {
}, throwable -> {
});
@ -253,8 +251,8 @@ public class GuildFragment extends BaseMainFragment implements Action1<Group> {
this.activity.supportInvalidateOptionsMenu();
}
@Override
public String customTitle() {
return getString(R.string.guild);
}
@Override
public String customTitle() {
return getString(R.string.guild);
}
}

6
Habitica/src/main/java/com/habitrpg/android/habitica/ui/fragments/social/GuildsOverviewFragment.java
View file

@ -68,9 +68,9 @@ public class GuildsOverviewFragment extends BaseMainFragment implements View.OnC
}
private void fetchGuilds() {
if (this.apiHelper != null && this.apiHelper.apiService != null) {
this.apiHelper.apiService.listGroups("guilds")
.compose(apiHelper.configureApiCallObserver())
if (this.apiClient != null && this.apiClient != null) {
this.apiClient.listGroups("guilds")
.subscribe(groups -> {
GuildsOverviewFragment.this.guilds = groups;
GuildsOverviewFragment.this.setGuildsOnListView();

7
Habitica/src/main/java/com/habitrpg/android/habitica/ui/fragments/social/InboxFragment.java
View file

@ -58,8 +58,8 @@ public class InboxFragment extends BaseMainFragment
Bundle savedInstanceState) {
super.onCreateView(inflater, container, savedInstanceState);
this.apiHelper.apiService.markPrivateMessagesRead()
.compose(apiHelper.configureApiCallObserver())
this.apiClient.markPrivateMessagesRead()
.subscribe(aVoid -> {}, throwable -> {});
View v = inflater.inflate(R.layout.fragment_inbox, container, false);
@ -125,8 +125,7 @@ public class InboxFragment extends BaseMainFragment
@Override
public void onRefresh() {
swipeRefreshLayout.setRefreshing(true);
this.apiHelper.retrieveUser(true)
.compose(apiHelper.configureApiCallObserver())
this.apiClient.retrieveUser(true)
.subscribe(new HabitRPGUserCallback(this), throwable -> {});
}

8
Habitica/src/main/java/com/habitrpg/android/habitica/ui/fragments/social/InboxMessageListFragment.java
View file

@ -80,8 +80,8 @@ public class InboxMessageListFragment extends BaseMainFragment
private void refreshUserInbox () {
this.swipeRefreshLayout.setRefreshing(true);
this.apiHelper.retrieveUser(true)
.compose(apiHelper.configureApiCallObserver())
this.apiClient.retrieveUser(true)
.subscribe(new HabitRPGUserCallback(this), throwable -> {});
}
@ -125,8 +125,8 @@ public class InboxMessageListFragment extends BaseMainFragment
messageObject.put("message", cmd.Message);
messageObject.put("toUserId", cmd.UserToSendTo);
apiHelper.apiService.postPrivateMessage(messageObject)
.compose(apiHelper.configureApiCallObserver())
apiClient.postPrivateMessage(messageObject)
.subscribe(postChatMessageResult -> {
this.refreshUserInbox();
}, throwable -> {

8
Habitica/src/main/java/com/habitrpg/android/habitica/ui/fragments/social/PublicGuildsFragment.java
View file

@ -50,7 +50,7 @@ public class PublicGuildsFragment extends BaseMainFragment implements SearchView
recyclerView.addItemDecoration(new DividerItemDecoration(getActivity(), DividerItemDecoration.VERTICAL_LIST));
viewAdapter = new PublicGuildsRecyclerViewAdapter();
viewAdapter.setMemberGuildIDs(this.memberGuildIDs);
viewAdapter.apiHelper = this.apiHelper;
viewAdapter.apiClient = this.apiClient;
recyclerView.setAdapter(viewAdapter);
if (this.guilds != null) {
this.viewAdapter.setPublicGuildList(this.guilds);
@ -71,9 +71,9 @@ public class PublicGuildsFragment extends BaseMainFragment implements SearchView
}
private void fetchGuilds() {
if (this.apiHelper != null) {
this.apiHelper.apiService.listGroups("publicGuilds")
.compose(apiHelper.configureApiCallObserver())
if (this.apiClient != null) {
this.apiClient.listGroups("publicGuilds")
.subscribe(groups -> {
PublicGuildsFragment.this.guilds = groups;
if (PublicGuildsFragment.this.viewAdapter != null) {

5
Habitica/src/main/java/com/habitrpg/android/habitica/ui/fragments/social/TavernFragment.java
View file

@ -55,9 +55,8 @@ public class TavernFragment extends BaseMainFragment {
@Override
public void onViewCreated(View view, Bundle savedInstanceState) {
super.onViewCreated(view, savedInstanceState);
if (this.apiHelper != null) {
apiHelper.apiService.getGroup("habitrpg")
.compose(apiHelper.configureApiCallObserver())
if (this.apiClient != null) {
apiClient.getGroup("habitrpg")
.subscribe(group -> {
TavernFragment.this.tavern = group;
if (group.quest != null && group.quest.key != null && TavernFragment.this.isAdded()) {

22
Habitica/src/main/java/com/habitrpg/android/habitica/ui/fragments/social/challenges/ChallegeDetailDialogHolder.java
View file

@ -11,7 +11,7 @@ import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.TextView;
import com.habitrpg.android.habitica.APIHelper;
import com.magicmicky.habitrpgwrapper.lib.api.IApiClient;
import com.habitrpg.android.habitica.HabiticaApplication;
import com.habitrpg.android.habitica.R;
import com.habitrpg.android.habitica.events.commands.OpenFullProfileCommand;
@ -19,6 +19,7 @@ import com.habitrpg.android.habitica.ui.activities.ChallengeDetailActivity;
import com.habitrpg.android.habitica.ui.adapter.social.ChallengesListViewAdapter;
import com.habitrpg.android.habitica.ui.helpers.MarkdownParser;
import com.habitrpg.android.habitica.ui.helpers.ViewHelper;
import com.magicmicky.habitrpgwrapper.lib.api.IApiClient;
import com.magicmicky.habitrpgwrapper.lib.models.Challenge;
import com.magicmicky.habitrpgwrapper.lib.models.HabitRPGUser;
import com.magicmicky.habitrpgwrapper.lib.models.tasks.Task;
@ -69,7 +70,7 @@ public class ChallegeDetailDialogHolder {
LinearLayout task_group_layout;
private AlertDialog dialog;
private APIHelper apiHelper;
private IApiClient apiClient;
private HabitRPGUser user;
private Challenge challenge;
private Action1<Challenge> challengeJoinedAction;
@ -82,10 +83,10 @@ public class ChallegeDetailDialogHolder {
ButterKnife.bind(this, view);
}
public void bind(AlertDialog dialog, APIHelper apiHelper, HabitRPGUser user, Challenge challenge,
public void bind(AlertDialog dialog, IApiClient apiClient, HabitRPGUser user, Challenge challenge,
Action1<Challenge> challengeJoinedAction, Action1<Challenge> challengeLeftAction) {
this.dialog = dialog;
this.apiHelper = apiHelper;
this.apiClient = apiClient;
this.user = user;
this.challenge = challenge;
this.challengeJoinedAction = challengeJoinedAction;
@ -104,8 +105,7 @@ public class ChallegeDetailDialogHolder {
gem_amount.setText(challenge.prize + "");
member_count.setText(challenge.memberCount + "");
apiHelper.apiService.getChallengeTasks(challenge.id)
.compose(this.apiHelper.configureApiCallObserver())
apiClient.getChallengeTasks(challenge.id)
.subscribe(taskList -> {
ArrayList<Task> todos = new ArrayList<>();
ArrayList<Task> habits = new ArrayList<>();
@ -290,8 +290,7 @@ public class ChallegeDetailDialogHolder {
@OnClick(R.id.challenge_join_btn)
public void joinChallenge() {
this.apiHelper.apiService.joinChallenge(challenge.id)
.compose(apiHelper.configureApiCallObserver())
this.apiClient.joinChallenge(challenge.id)
.subscribe(challenge -> {
challenge.user_id = this.user.getId();
challenge.async().save();
@ -310,8 +309,7 @@ public class ChallegeDetailDialogHolder {
new AlertDialog.Builder(context)
.setTitle(context.getString(R.string.challenge_leave_title))
.setMessage(String.format(context.getString(R.string.challenge_leave_text), challenge.name))
.setPositiveButton(context.getString(R.string.yes), (dialog, which) -> this.apiHelper.apiService.leaveChallenge(challenge.id)
.compose(apiHelper.configureApiCallObserver())
.setPositiveButton(context.getString(R.string.yes), (dialog, which) -> this.apiClient.leaveChallenge(challenge.id)
.subscribe(aVoid -> {
challenge.user_id = null;
challenge.async().save();
@ -330,7 +328,7 @@ public class ChallegeDetailDialogHolder {
}
public static void showDialog(Activity activity, APIHelper apiHelper, HabitRPGUser user, Challenge challenge,
public static void showDialog(Activity activity, IApiClient apiClient, HabitRPGUser user, Challenge challenge,
Action1<Challenge> challengeJoinedAction, Action1<Challenge> challengeLeftAction) {
View dialogLayout = activity.getLayoutInflater().inflate(R.layout.dialog_challenge_detail, null);
@ -339,6 +337,6 @@ public class ChallegeDetailDialogHolder {
AlertDialog.Builder builder = new AlertDialog.Builder(activity)
.setView(dialogLayout);
challegeDetailDialogHolder.bind(builder.show(), apiHelper, user, challenge, challengeJoinedAction, challengeLeftAction);
challegeDetailDialogHolder.bind(builder.show(), apiClient, user, challenge, challengeJoinedAction, challengeLeftAction);
}
}

4
Habitica/src/main/java/com/habitrpg/android/habitica/ui/fragments/social/challenges/ChallengeTasksRecyclerViewFragment.java
View file

@ -1,7 +1,7 @@
package com.habitrpg.android.habitica.ui.fragments.social.challenges;
import com.habitrpg.android.habitica.APIHelper;
import com.magicmicky.habitrpgwrapper.lib.api.IApiClient;
import com.habitrpg.android.habitica.R;
import com.habitrpg.android.habitica.components.AppComponent;
import com.habitrpg.android.habitica.helpers.TagsHelper;
@ -37,7 +37,7 @@ public class ChallengeTasksRecyclerViewFragment extends BaseFragment {
@Named("UserID")
String userID;
@Inject
APIHelper apiHelper;
IApiClient apiClient;
ObservableList<Task> tasksOnInitialize;

8
Habitica/src/main/java/com/habitrpg/android/habitica/ui/fragments/social/challenges/ChallengesOverviewFragment.java
View file

@ -25,8 +25,6 @@ import org.greenrobot.eventbus.Subscribe;
import java.util.ArrayList;
import java.util.Stack;
import rx.Observable;
import rx.subjects.AsyncSubject;
import rx.subjects.PublishSubject;
public class ChallengesOverviewFragment extends BaseMainFragment {
@ -71,8 +69,8 @@ public class ChallengesOverviewFragment extends BaseMainFragment {
}
private void subscribeGetChallenges(){
this.apiHelper.apiService.getUserChallenges()
.compose(apiHelper.configureApiCallObserver())
this.apiClient.getUserChallenges()
.subscribe(challenges -> {
getUserChallengesObservable.onNext(challenges);
}, e -> {
@ -153,7 +151,7 @@ public class ChallengesOverviewFragment extends BaseMainFragment {
public void onEvent(ShowChallengeDetailDialogCommand cmd) {
Challenge challenge = new Select().from(Challenge.class).where(Condition.column("id").is(cmd.challengeId)).querySingle();
ChallegeDetailDialogHolder.showDialog(HabiticaApplication.currentActivity, apiHelper, user, challenge, challenge1 -> {
ChallegeDetailDialogHolder.showDialog(HabiticaApplication.currentActivity, apiClient, user, challenge, challenge1 -> {
// challenge joined
userChallengesFragment.addItem(challenge1);
availableChallengesFragment.updateItem(challenge1);

17
Habitica/src/main/java/com/habitrpg/android/habitica/ui/fragments/social/party/PartyFragment.java
View file

@ -64,8 +64,7 @@ public class PartyFragment extends BaseMainFragment {
// Get the full group data
if (this.user != null && this.user.getParty() != null && this.user.getParty().id != null) {
apiHelper.apiService.getGroup("party")
.compose(this.apiHelper.configureApiCallObserver())
apiClient.getGroup("party")
.subscribe(group -> {
if (group == null) {
return;
@ -74,8 +73,8 @@ public class PartyFragment extends BaseMainFragment {
updateGroupUI();
apiHelper.apiService.getGroupMembers(group.id, true)
.compose(apiHelper.configureApiCallObserver())
apiClient.getGroupMembers(group.id, true)
.subscribe(members -> {
PartyFragment.this.group.members = members;
updateGroupUI();
@ -166,7 +165,7 @@ public class PartyFragment extends BaseMainFragment {
this.displayEditForm();
return true;
case R.id.menu_guild_leave:
this.apiHelper.apiService.leaveGroup(this.group.id).compose(apiHelper.configureApiCallObserver())
this.apiClient.leaveGroup(this.group.id)
.subscribe(group -> {
getActivity().getSupportFragmentManager().beginTransaction().remove(PartyFragment.this).commit();
}, throwable -> {
@ -215,8 +214,8 @@ public class PartyFragment extends BaseMainFragment {
needsSaving = true;
}
if (needsSaving) {
this.apiHelper.apiService.updateGroup(this.group.id, this.group)
.compose(apiHelper.configureApiCallObserver())
this.apiClient.updateGroup(this.group.id, this.group)
.subscribe(aVoid -> {
}, throwable -> {
});
@ -245,8 +244,8 @@ public class PartyFragment extends BaseMainFragment {
Collections.addAll(invites, userIDs);
inviteData.put("uuids", invites);
}
this.apiHelper.apiService.inviteToGroup(this.group.id, inviteData)
.compose(apiHelper.configureApiCallObserver())
this.apiClient.inviteToGroup(this.group.id, inviteData)
.subscribe(aVoid -> {
}, throwable -> {
});

7
Habitica/src/main/java/com/habitrpg/android/habitica/ui/fragments/tasks/TaskRecyclerViewFragment.java
View file

@ -10,7 +10,7 @@ import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import com.habitrpg.android.habitica.APIHelper;
import com.magicmicky.habitrpgwrapper.lib.api.IApiClient;
import com.habitrpg.android.habitica.R;
import com.habitrpg.android.habitica.components.AppComponent;
import com.habitrpg.android.habitica.events.commands.AddNewTaskCommand;
@ -24,7 +24,6 @@ import com.habitrpg.android.habitica.ui.adapter.tasks.TodosRecyclerViewAdapter;
import com.habitrpg.android.habitica.ui.fragments.BaseFragment;
import com.habitrpg.android.habitica.ui.helpers.ItemTouchHelperAdapter;
import com.habitrpg.android.habitica.ui.helpers.ItemTouchHelperDropCallback;
import com.habitrpg.android.habitica.ui.menu.DividerItemDecoration;
import com.magicmicky.habitrpgwrapper.lib.models.HabitRPGUser;
import com.magicmicky.habitrpgwrapper.lib.models.tasks.Task;
@ -47,7 +46,7 @@ public class TaskRecyclerViewFragment extends BaseFragment implements View.OnCli
@Named("UserID")
String userID;
@Inject
APIHelper apiHelper;
IApiClient apiClient;
@Inject
TagsHelper tagsHelper;
LinearLayoutManager layoutManager = null;
@ -93,7 +92,7 @@ public class TaskRecyclerViewFragment extends BaseFragment implements View.OnCli
return;
case Task.TYPE_REWARD:
layoutOfType = R.layout.reward_item_card;
this.recyclerAdapter = new RewardsRecyclerViewAdapter(Task.TYPE_REWARD, tagsHelper, layoutOfType, getContext(), user, apiHelper);
this.recyclerAdapter = new RewardsRecyclerViewAdapter(Task.TYPE_REWARD, tagsHelper, layoutOfType, getContext(), user, apiClient);
break;
}
}

36
Habitica/src/main/java/com/habitrpg/android/habitica/ui/fragments/tasks/TasksFragment.java
View file

@ -198,9 +198,9 @@ public class TasksFragment extends BaseMainFragment implements OnCheckedChangeLi
refreshItem.setActionView(iv);
if (apiHelper != null) {
apiHelper.retrieveUser(true)
.compose(apiHelper.configureApiCallObserver())
if (apiClient != null) {
apiClient.retrieveUser(true)
.subscribe(
new HabitRPGUserCallback(activity),
throwable -> stopAnimatingRefreshItem()
@ -218,9 +218,9 @@ public class TasksFragment extends BaseMainFragment implements OnCheckedChangeLi
TaskRecyclerViewFragment fragment;
SortableTasksRecyclerViewAdapter.SortTasksCallback sortCallback =
(task, from, to) -> {
if (apiHelper != null){
apiHelper.apiService.postTaskNewPosition(task.getId(), String.valueOf(to))
.compose(apiHelper.configureApiCallObserver())
if (apiClient != null){
apiClient.postTaskNewPosition(task.getId(), String.valueOf(to))
.subscribe(aVoid -> {}, e -> {});
}
};
@ -319,9 +319,9 @@ public class TasksFragment extends BaseMainFragment implements OnCheckedChangeLi
UiUtils.dismissKeyboard(activity);
final Tag t = new Tag();
t.setName(event.tagName);
if (apiHelper != null) {
apiHelper.apiService.createTag(t)
.compose(apiHelper.configureApiCallObserver())
if (apiClient != null) {
apiClient.createTag(t)
.subscribe(tag -> {
// Since we get a list of all tags, we just save them all
tag.user_id = user.getId();
@ -338,9 +338,9 @@ public class TasksFragment extends BaseMainFragment implements OnCheckedChangeLi
@Subscribe
public void onEvent(final DeleteTagCommand event) {
final Tag t = event.tag;
if (apiHelper != null) {
apiHelper.apiService.deleteTag(t.getId())
.compose(apiHelper.configureApiCallObserver())
if (apiClient != null) {
apiClient.deleteTag(t.getId())
.subscribe(tag -> {
tagFilterMap.remove(t.getId());
filterChangedHandler.hit();
@ -361,9 +361,9 @@ public class TasksFragment extends BaseMainFragment implements OnCheckedChangeLi
public void onEvent(final UpdateTagCommand event) {
final Tag t = event.tag;
final String uuid = event.uuid;
if (apiHelper != null) {
apiHelper.apiService.updateTag(uuid,t)
.compose(apiHelper.configureApiCallObserver())
if (apiClient != null) {
apiClient.updateTag(uuid,t)
.subscribe(tag -> {
UiUtils.dismissKeyboard(this.activity);
updateTagFilterDrawerItem(tag);
@ -376,9 +376,9 @@ public class TasksFragment extends BaseMainFragment implements OnCheckedChangeLi
@Subscribe
public void onEvent(RefreshUserCommand event) {
if (apiHelper != null) {
apiHelper.retrieveUser(true)
.compose(apiHelper.configureApiCallObserver())
if (apiClient != null) {
apiClient.retrieveUser(true)
.subscribe(
new HabitRPGUserCallback(activity),
throwable -> stopAnimatingRefreshItem()

6
Habitica/src/main/java/com/habitrpg/android/habitica/widget/AvatarStatsWidgetProvider.java
View file

@ -1,6 +1,6 @@
package com.habitrpg.android.habitica.widget;
import com.habitrpg.android.habitica.APIHelper;
import com.magicmicky.habitrpgwrapper.lib.api.IApiClient;
import com.habitrpg.android.habitica.HabiticaApplication;
import com.habitrpg.android.habitica.HabiticaBaseApplication;
import com.habitrpg.android.habitica.HostConfig;
@ -36,12 +36,12 @@ public class AvatarStatsWidgetProvider extends BaseWidgetProvider {
}
@Inject
APIHelper apiHelper;
IApiClient apiClient;
@Inject
HostConfig hostConfig;
private void setUp(Context context) {
if (apiHelper == null) {
if (apiClient == null) {
HabiticaBaseApplication application = HabiticaApplication.getInstance(context);
application.getComponent().inject(this);
}

6
Habitica/src/main/java/com/habitrpg/android/habitica/widget/DailiesWidgetProvider.java
View file

@ -2,7 +2,7 @@ package com.habitrpg.android.habitica.widget;
import android.content.Context;
import com.habitrpg.android.habitica.APIHelper;
import com.magicmicky.habitrpgwrapper.lib.api.IApiClient;
import com.habitrpg.android.habitica.HabiticaApplication;
import com.habitrpg.android.habitica.HabiticaBaseApplication;
import com.habitrpg.android.habitica.HostConfig;
@ -16,12 +16,12 @@ public class DailiesWidgetProvider extends TaskListWidgetProvider{
public static final String TASK_ID_ITEM = "com.habitrpg.android.habitica.TASK_ID_ITEM";
@Inject
APIHelper apiHelper;
IApiClient apiClient;
@Inject
HostConfig hostConfig;
private void setUp(Context context) {
if (apiHelper == null) {
if (apiClient == null) {
HabiticaBaseApplication application = HabiticaApplication.getInstance(context);
application.getComponent().inject(this);
}

18
Habitica/src/main/java/com/habitrpg/android/habitica/widget/HabitButtonWidgetProvider.java
View file

@ -7,38 +7,30 @@ import android.content.Intent;
import android.os.Build;
import android.os.Bundle;
import android.widget.RemoteViews;
import android.widget.Toast;
import com.habitrpg.android.habitica.APIHelper;
import com.magicmicky.habitrpgwrapper.lib.api.IApiClient;
import com.habitrpg.android.habitica.HabiticaApplication;
import com.habitrpg.android.habitica.HabiticaBaseApplication;
import com.habitrpg.android.habitica.HostConfig;
import com.habitrpg.android.habitica.R;
import com.habitrpg.android.habitica.ui.helpers.UiUtils;
import com.magicmicky.habitrpgwrapper.lib.models.HabitRPGUser;
import com.magicmicky.habitrpgwrapper.lib.models.Stats;
import com.magicmicky.habitrpgwrapper.lib.models.TaskDirectionData;
import com.magicmicky.habitrpgwrapper.lib.models.tasks.Task;
import com.raizlabs.android.dbflow.sql.builder.Condition;
import com.raizlabs.android.dbflow.sql.language.Select;
import javax.inject.Inject;
import static com.habitrpg.android.habitica.ui.activities.MainActivity.MIN_LEVEL_FOR_SKILLS;
import static com.habitrpg.android.habitica.ui.activities.MainActivity.round;
public class HabitButtonWidgetProvider extends BaseWidgetProvider {
public static final String HABIT_ACTION = "com.habitrpg.android.habitica.HABIT_ACTION";
public static final String TASK_ID = "com.habitrpg.android.habitica.TASK_ID_ITEM";
public static final String TASK_DIRECTION = "com.habitrpg.android.habitica.TASK_DIRECTION";
@Inject
public APIHelper apiHelper;
public IApiClient apiClient;
@Inject
public HostConfig hostConfig;
private void setUp(Context context) {
if (apiHelper == null) {
if (apiClient == null) {
HabiticaBaseApplication application = HabiticaApplication.getInstance(context);
application.getComponent().inject(this);
}
@ -85,8 +77,8 @@ public class HabitButtonWidgetProvider extends BaseWidgetProvider {
int[] ids = {appWidgetId};
if (taskId != null) {
apiHelper.apiService.postTaskDirection(taskId, direction)
.compose(apiHelper.configureApiCallObserver())
apiClient.postTaskDirection(taskId, direction)
.subscribe(taskDirectionData -> {
Task task = new Select().from(Task.class).where(Condition.column("id").eq(taskId)).querySingle();
task.value = task.value + taskDirectionData.getDelta();

10
Habitica/src/main/java/com/habitrpg/android/habitica/widget/TaskListWidgetProvider.java
View file

@ -10,7 +10,7 @@ import android.os.Build;
import android.os.Bundle;
import android.widget.RemoteViews;
import com.habitrpg.android.habitica.APIHelper;
import com.magicmicky.habitrpgwrapper.lib.api.IApiClient;
import com.habitrpg.android.habitica.HabiticaApplication;
import com.habitrpg.android.habitica.HabiticaBaseApplication;
import com.habitrpg.android.habitica.HostConfig;
@ -28,12 +28,12 @@ public abstract class TaskListWidgetProvider extends BaseWidgetProvider {
public static final String TASK_ID_ITEM = "com.habitrpg.android.habitica.TASK_ID_ITEM";
@Inject
APIHelper apiHelper;
IApiClient apiClient;
@Inject
HostConfig hostConfig;
private void setUp(Context context) {
if (apiHelper == null) {
if (apiClient == null) {
HabiticaBaseApplication application = HabiticaApplication.getInstance(context);
application.getComponent().inject(this);
}
@ -54,8 +54,8 @@ public abstract class TaskListWidgetProvider extends BaseWidgetProvider {
String taskId = intent.getStringExtra(TASK_ID_ITEM);
if (taskId != null) {
apiHelper.apiService.postTaskDirection(taskId, TaskDirection.up.toString())
.compose(apiHelper.configureApiCallObserver())
apiClient.postTaskDirection(taskId, TaskDirection.up.toString())
.subscribe(taskDirectionData -> {
Task task = new Select().from(Task.class).where(Condition.column("id").eq(taskId)).querySingle();
task.completed = true;

221
Habitica/src/main/java/com/magicmicky/habitrpgwrapper/lib/api/IApiClient.java Normal file
View file

@ -0,0 +1,221 @@
package com.magicmicky.habitrpgwrapper.lib.api;
import com.habitrpg.android.habitica.ApiClient;
import com.magicmicky.habitrpgwrapper.lib.api.IApiClient;
import com.magicmicky.habitrpgwrapper.lib.models.AchievementResult;
import com.magicmicky.habitrpgwrapper.lib.models.Challenge;
import com.magicmicky.habitrpgwrapper.lib.models.ChatMessage;
import com.magicmicky.habitrpgwrapper.lib.models.ContentResult;
import com.magicmicky.habitrpgwrapper.lib.models.Group;
import com.magicmicky.habitrpgwrapper.lib.models.HabitRPGUser;
import com.magicmicky.habitrpgwrapper.lib.models.Items;
import com.magicmicky.habitrpgwrapper.lib.models.PostChatMessageResult;
import com.magicmicky.habitrpgwrapper.lib.models.PurchaseValidationRequest;
import com.magicmicky.habitrpgwrapper.lib.models.PurchaseValidationResult;
import com.magicmicky.habitrpgwrapper.lib.models.Quest;
import com.magicmicky.habitrpgwrapper.lib.models.Shop;
import com.magicmicky.habitrpgwrapper.lib.models.Status;
import com.magicmicky.habitrpgwrapper.lib.models.Tag;
import com.magicmicky.habitrpgwrapper.lib.models.TaskDirectionData;
import com.magicmicky.habitrpgwrapper.lib.models.UserAuth;
import com.magicmicky.habitrpgwrapper.lib.models.UserAuthResponse;
import com.magicmicky.habitrpgwrapper.lib.models.UserAuthSocial;
import com.magicmicky.habitrpgwrapper.lib.models.responses.BuyResponse;
import com.magicmicky.habitrpgwrapper.lib.models.responses.FeedResponse;
import com.magicmicky.habitrpgwrapper.lib.models.responses.HabitResponse;
import com.magicmicky.habitrpgwrapper.lib.models.responses.SkillResponse;
import com.magicmicky.habitrpgwrapper.lib.models.responses.UnlockResponse;
import com.magicmicky.habitrpgwrapper.lib.models.tasks.ItemData;
import com.magicmicky.habitrpgwrapper.lib.models.tasks.Task;
import com.magicmicky.habitrpgwrapper.lib.models.tasks.TaskList;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import retrofit2.adapter.rxjava.HttpException;
import rx.Observable;
public interface IApiClient {
void setLanguageCode(String languageCode);
Observable<Status> getStatus();
Observable<ContentResult> getContent();
Observable<ContentResult> getContent(String language);
/* user API */
Observable<HabitRPGUser> getUser();
Observable<HabitRPGUser> updateUser(Map<String, Object> updateDictionary);
Observable<HabitRPGUser> registrationLanguage(String registrationLanguage);
Observable<List<ItemData>> getInventoryBuyableGear();
Observable<Items> equipItem(String type, String itemKey);
Observable<BuyResponse> buyItem(String itemKey);
Observable<Void> purchaseItem(String type, String itemKey);
Observable<Void> purchaseHourglassItem(String type, String itemKey);
Observable<Void> purchaseMysterySet(String itemKey);
Observable<Void> purchaseQuest(String key);
Observable<HabitRPGUser> sellItem(String itemType, String itemKey);
Observable<FeedResponse> feedPet(String petKey, String foodKey);
Observable<Items> hatchPet(String eggKey, String hatchingPotionKey);
Observable<TaskList> getTasks();
Observable<UnlockResponse> unlockPath(String path);
Observable<Task> getTask(String id);
Observable<TaskDirectionData> postTaskDirection(String id, String direction);
Observable<ArrayList<String>> postTaskNewPosition(String id, String position);
Observable<Task> scoreChecklistItem(String taskId, String itemId);
Observable<Task> createItem(Task item);
Observable<List<Task>> createTasks(List<Task> tasks);
Observable<Task> updateTask(String id, Task item);
Observable<Void> deleteTask( String id);
Observable<Tag> createTag(Tag tag);
Observable<Tag> updateTag(String id, Tag tag);
Observable<Void> deleteTag(String id);
Observable<UserAuthResponse> registerUser(UserAuth auth);
Observable<UserAuthResponse> registerUser(String username, String email, String password, String confirmPassword);
Observable<UserAuthResponse> connectLocal(UserAuth auth);
Observable<UserAuthResponse> connectUser(String username, String password);
Observable<UserAuthResponse> connectSocial(UserAuthSocial auth);
Observable<UserAuthResponse> connectSocial(String network, String userId, String accessToken);
Observable<Void> sleep();
Observable<HabitRPGUser> revive();
Observable<SkillResponse> useSkill( String skillName, String targetType, String targetId);
Observable<SkillResponse> useSkill( String skillName, String targetType);
Observable<HabitRPGUser> changeClass();
Observable<HabitRPGUser> changeClass(String className);
Observable<HabitRPGUser> disableClasses();
Observable<Void> markPrivateMessagesRead();
/* Group API */
Observable<List<Group>> listGroups(String type);
Observable<Group> getGroup(String groupId);
Observable<Void> updateGroup( String id, Group item);
Observable<List<ChatMessage>> listGroupChat( String groupId);
Observable<Group> joinGroup(String groupId);
Observable<Void> leaveGroup( String groupId);
Observable<PostChatMessageResult> postGroupChat( String groupId, HashMap<String, String> message);
Observable<Void> deleteMessage( String groupId, String messageId);
Observable<List<HabitRPGUser>> getGroupMembers( String groupId, Boolean includeAllPublicFields);
Observable<List<HabitRPGUser>> getGroupMembers( String groupId, Boolean includeAllPublicFields, String lastId);
// Like returns the full chat list
Observable<ChatMessage> likeMessage( String groupId, String mid);
Observable<Void> flagMessage(String groupId, String mid);
Observable<Void> seenMessages(String groupId);
Observable<Void> inviteToGroup( String groupId, Map<String, Object> inviteData);
Observable<Void> rejectGroupInvite(String groupId);
Observable<Void> acceptQuest(String groupId);
Observable<Void> rejectQuest(String groupId);
Observable<Void> cancelQuest( String groupId);
Observable<Quest> forceStartQuest( String groupId, Group group);
Observable<Quest> inviteToQuest( String groupId,String questKey);
Observable<Quest> abortQuest( String groupId);
Observable<Void> leaveQuest(String groupId);
Observable<PurchaseValidationResult> validatePurchase(PurchaseValidationRequest request);
Observable<HabitRPGUser> changeCustomDayStart(Map<String, Object> updateObject);
//Members URL
Observable<HabitRPGUser> GetMember(String memberId);
Observable<AchievementResult> GetMemberAchievements(String memberId);
Observable<PostChatMessageResult> postPrivateMessage(HashMap<String, String> messageDetails);
Observable<Shop> fetchShopInventory(String identifier);
//Push notifications
Observable<Void> addPushDevice( Map<String, String> pushDeviceData);
Observable<Void> deletePushDevice(String regId);
/* challenges api */
Observable<ArrayList<Challenge>> getUserChallenges();
Observable<TaskList> getChallengeTasks( String challengeId);
Observable<Challenge> getChallenge(String challengeId);
Observable<Challenge> joinChallenge(String challengeId);
Observable<Void> leaveChallenge(String challengeId);
//DEBUG: These calls only work on a local development server
Observable<Void> debugAddTenGems();
// Notifications
Observable<Void> readNotificaiton(String notificationId);
ApiClient.ErrorResponse getErrorResponse(HttpException throwable);
void updateAuthenticationCredentials(String userID, String apiToken);
boolean hasAuthenticationKeys();
Observable<HabitRPGUser> retrieveUser(boolean b);
<T> Observable.Transformer<HabitResponse<T>, T> configureApiCallObserver();
}

10
Habitica/src/test/java/com/habitrpg/android/habitica/api/BaseAPITests.java
View file

@ -1,7 +1,7 @@
package com.habitrpg.android.habitica.api;
import com.habitrpg.android.habitica.APIHelper;
import com.magicmicky.habitrpgwrapper.lib.api.IApiClient;
import com.habitrpg.android.habitica.BuildConfig;
import com.habitrpg.android.habitica.HostConfig;
import com.magicmicky.habitrpgwrapper.lib.models.HabitRPGUser;
@ -18,7 +18,7 @@ import rx.observers.TestSubscriber;
public class BaseAPITests {
public APIHelper apiHelper;
public IApiClient apiClient;
public HostConfig hostConfig;
public String username;
@ -33,14 +33,14 @@ public class BaseAPITests {
BuildConfig.PORT,
"",
"");
apiHelper = new APIHelper(APIHelper.createGsonFactory(), hostConfig);
apiClient = new ApiClient(ApiClient.createGsonFactory(), hostConfig);
generateUser();
}
public void generateUser() {
TestSubscriber<HabitResponse<UserAuthResponse>> testSubscriber = new TestSubscriber<>();
username = UUID.randomUUID().toString();
apiHelper.registerUser(username, username+"@example.com", password, password)
apiClient.registerUser(username, username+"@example.com", password, password)
.subscribe(testSubscriber);
testSubscriber.assertCompleted();
UserAuthResponse response = testSubscriber.getOnNextEvents().get(0).getData();
@ -51,7 +51,7 @@ public class BaseAPITests {
public HabitRPGUser getUser() {
TestSubscriber<HabitResponse<HabitRPGUser>> userSubscriber = new TestSubscriber<>();
apiHelper.apiService.getUser().subscribe(userSubscriber);
apiClient.getUser().subscribe(userSubscriber);
userSubscriber.assertNoErrors();
userSubscriber.assertCompleted();
HabitRPGUser user = userSubscriber.getOnNextEvents().get(0).getData();

8
Habitica/src/test/java/com/habitrpg/android/habitica/api/SocialAPITests.java
View file

@ -38,7 +38,7 @@ public class SocialAPITests extends BaseAPITests {
HashMap<String, String> messageObject = new HashMap<>();
messageObject.put("message", "Foo Bar"+messageSuffix);
TestSubscriber<HabitResponse<PostChatMessageResult>> testSubscriber = new TestSubscriber<>();
apiHelper.apiService.postGroupChat(groupID, messageObject).subscribe(testSubscriber);
apiClient.postGroupChat(groupID, messageObject).subscribe(testSubscriber);
testSubscriber.assertNoErrors();
testSubscriber.assertCompleted();
PostChatMessageResult result = testSubscriber.getOnNextEvents().get(0).getData();
@ -51,7 +51,7 @@ public class SocialAPITests extends BaseAPITests {
postMessage(groupID, "1");
TestSubscriber<HabitResponse<Group>> testSubscriber = new TestSubscriber<>();
apiHelper.apiService.getGroup(groupID).subscribe(testSubscriber);
apiClient.getGroup(groupID).subscribe(testSubscriber);
testSubscriber.assertNoErrors();
testSubscriber.assertCompleted();
testSubscriber.assertValueCount(1);
@ -64,7 +64,7 @@ public class SocialAPITests extends BaseAPITests {
postMessage(groupID, "2");
TestSubscriber<HabitResponse<List<ChatMessage>>> testSubscriber = new TestSubscriber<>();
apiHelper.apiService.listGroupChat(groupID).subscribe(testSubscriber);
apiClient.listGroupChat(groupID).subscribe(testSubscriber);
testSubscriber.assertNoErrors();
testSubscriber.assertCompleted();
testSubscriber.assertValueCount(1);
@ -74,7 +74,7 @@ public class SocialAPITests extends BaseAPITests {
public void tearDown() {
TestSubscriber<HabitResponse<Void>> testSubscriber = new TestSubscriber<>();
for (String messageID : this.messagesIDs) {
apiHelper.apiService.deleteMessage("habitrpg", messageID)
apiClient.deleteMessage("habitrpg", messageID)
.subscribe(testSubscriber);
testSubscriber.assertNoErrors();
testSubscriber.assertCompleted();

6
Habitica/src/test/java/com/habitrpg/android/habitica/api/TagAPITests.java
View file

@ -26,7 +26,7 @@ public class TagAPITests extends BaseAPITests {
TestSubscriber<HabitResponse<Tag>> testSubscriber = new TestSubscriber<>();
Tag tag = new Tag();
tag.setName("foo");
apiHelper.apiService.createTag(tag).subscribe(testSubscriber);
apiClient.createTag(tag).subscribe(testSubscriber);
testSubscriber.assertNoErrors();
testSubscriber.assertCompleted();
testSubscriber.assertValueCount(1);
@ -44,7 +44,7 @@ public class TagAPITests extends BaseAPITests {
//Attempt to update the test user's first tag
String testId = getUser().getTags().get(0).getId();
apiHelper.apiService.updateTag(testId,t).subscribe(testSubscriber);
apiClient.updateTag(testId,t).subscribe(testSubscriber);
testSubscriber.assertNoErrors();
testSubscriber.assertCompleted();
Assert.assertEquals(newname,testSubscriber.getOnNextEvents().get(0).getData().getName());
@ -56,7 +56,7 @@ public class TagAPITests extends BaseAPITests {
TestSubscriber<HabitResponse<Void>> testSub = new TestSubscriber<>();
String testId = getUser().getTags().get(0).getId();
apiHelper.apiService.deleteTag(testId).subscribe(testSub);
apiClient.deleteTag(testId).subscribe(testSub);
testSub.assertNoErrors();
testSub.assertCompleted();
}

16
Habitica/src/test/java/com/habitrpg/android/habitica/api/TaskAPITests.java
View file

@ -36,10 +36,10 @@ public class TaskAPITests extends BaseAPITests {
public void setUp() {
super.setUp();
TestSubscriber<HabitResponse<TaskList>> oldTaskSubscriber = new TestSubscriber<>();
apiHelper.apiService.getTasks().subscribe(oldTaskSubscriber);
apiClient.getTasks().subscribe(oldTaskSubscriber);
TaskList tasks = oldTaskSubscriber.getOnNextEvents().get(0).getData();
for (Task task : tasks.tasks.values()) {
apiHelper.apiService.deleteTask(task.getId()).subscribe(new TestSubscriber<>());
apiClient.deleteTask(task.getId()).subscribe(new TestSubscriber<>());
}
List<Task> randomTasks = new ArrayList<>();
@ -56,7 +56,7 @@ public class TaskAPITests extends BaseAPITests {
reward1 = randomTasks.get(6);
randomTasks.add(createRandomTask("8", "reward"));
TestSubscriber<HabitResponse<List<Task>>> testSubscriber = new TestSubscriber<>();
apiHelper.apiService.createTasks(randomTasks).subscribe(testSubscriber);
apiClient.createTasks(randomTasks).subscribe(testSubscriber);
testSubscriber.assertNoErrors();
testSubscriber.assertCompleted();
}
@ -75,7 +75,7 @@ public class TaskAPITests extends BaseAPITests {
@Test
public void shouldLoadAllTasksFromServer() {
TestSubscriber<HabitResponse<TaskList>> testSubscriber = new TestSubscriber<>();
apiHelper.apiService.getTasks().subscribe(testSubscriber);
apiClient.getTasks().subscribe(testSubscriber);
testSubscriber.assertNoErrors();
testSubscriber.assertCompleted();
TaskList taskList = testSubscriber.getOnNextEvents().get(0).getData();
@ -85,7 +85,7 @@ public class TaskAPITests extends BaseAPITests {
@Test
public void shouldBeAbleToScoreTaskUp() {
TestSubscriber<HabitResponse<TaskDirectionData>> testSubscriber = new TestSubscriber<>();
apiHelper.apiService.postTaskDirection(habit1.getId(), "up").subscribe(testSubscriber);
apiClient.postTaskDirection(habit1.getId(), "up").subscribe(testSubscriber);
testSubscriber.assertNoErrors();
testSubscriber.assertCompleted();
TaskDirectionData data = testSubscriber.getOnNextEvents().get(0).getData();
@ -95,7 +95,7 @@ public class TaskAPITests extends BaseAPITests {
@Test
public void shouldBeAbleToScoreTaskDown() {
TestSubscriber<HabitResponse<TaskDirectionData>> testSubscriber = new TestSubscriber<>();
apiHelper.apiService.postTaskDirection(habit1.getId(), "down").subscribe(testSubscriber);
apiClient.postTaskDirection(habit1.getId(), "down").subscribe(testSubscriber);
testSubscriber.assertNoErrors();
testSubscriber.assertCompleted();
TaskDirectionData data = testSubscriber.getOnNextEvents().get(0).getData();
@ -105,11 +105,11 @@ public class TaskAPITests extends BaseAPITests {
@Test
public void shouldBeAbleToDeleteATask() {
TestSubscriber<HabitResponse<Void>> testSubscriber = new TestSubscriber<>();
apiHelper.apiService.deleteTask(habit1.getId()).subscribe(testSubscriber);
apiClient.deleteTask(habit1.getId()).subscribe(testSubscriber);
testSubscriber.assertCompleted();
testSubscriber.assertNoErrors();
TestSubscriber<HabitResponse<TaskList>> newTaskListSubscriber = new TestSubscriber<>();
apiHelper.apiService.getTasks().subscribe(newTaskListSubscriber);
apiClient.getTasks().subscribe(newTaskListSubscriber);
TaskList taskList = newTaskListSubscriber.getOnNextEvents().get(0).getData();
assertEquals(7, taskList.tasks.size());
}

11
Habitica/src/test/java/com/habitrpg/android/habitica/api/UserAPITests.java
View file

@ -5,9 +5,6 @@ import com.habitrpg.android.habitica.BuildConfig;
import com.magicmicky.habitrpgwrapper.lib.models.HabitRPGUser;
import com.magicmicky.habitrpgwrapper.lib.models.UserAuthResponse;
import com.magicmicky.habitrpgwrapper.lib.models.responses.HabitResponse;
import com.magicmicky.habitrpgwrapper.lib.models.tasks.TaskList;
import junit.framework.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
@ -30,7 +27,7 @@ public class UserAPITests extends BaseAPITests {
@Test
public void shouldLoadUserFromServer() {
TestSubscriber<HabitResponse<HabitRPGUser>> testSubscriber = new TestSubscriber<>();
apiHelper.apiService.getUser().subscribe(testSubscriber);
apiClient.getUser().subscribe(testSubscriber);
testSubscriber.assertNoErrors();
testSubscriber.assertCompleted();
testSubscriber.assertValueCount(1);
@ -39,7 +36,7 @@ public class UserAPITests extends BaseAPITests {
@Test
public void shouldLoadCompleteUserFromServer() {
TestSubscriber<HabitResponse<HabitRPGUser>> testSubscriber = new TestSubscriber<>();
apiHelper.retrieveUser(true).subscribe(testSubscriber);
apiClient.retrieveUser(true).subscribe(testSubscriber);
testSubscriber.assertNoErrors();
testSubscriber.assertCompleted();
testSubscriber.assertValueCount(1);
@ -51,7 +48,7 @@ public class UserAPITests extends BaseAPITests {
hostConfig.setApi("");
TestSubscriber<HabitResponse<UserAuthResponse>> testSubscriber = new TestSubscriber<>();
username = UUID.randomUUID().toString();
apiHelper.registerUser(username, username+"@example.com", password, password)
apiClient.registerUser(username, username+"@example.com", password, password)
.subscribe(testSubscriber);
testSubscriber.assertNoErrors();
testSubscriber.assertCompleted();
@ -64,7 +61,7 @@ public class UserAPITests extends BaseAPITests {
@Test
public void shouldLoginExistingUser() {
TestSubscriber<HabitResponse<UserAuthResponse>> testSubscriber = new TestSubscriber<>();
apiHelper.connectUser(username, password).subscribe(testSubscriber);
apiClient.connectUser(username, password).subscribe(testSubscriber);
testSubscriber.assertNoErrors();
testSubscriber.assertCompleted();
UserAuthResponse response = testSubscriber.getOnNextEvents().get(0).getData();

23
Habitica/src/test/java/com/habitrpg/android/habitica/helpers/PopupNotificationsManagerTest.java
View file

@ -2,47 +2,32 @@ package com.habitrpg.android.habitica.helpers;
import android.app.Activity;
import android.app.AlertDialog;
import android.content.Context;
import android.os.Build;
import com.habitrpg.android.habitica.APIHelper;
import com.magicmicky.habitrpgwrapper.lib.api.IApiClient;
import com.habitrpg.android.habitica.BuildConfig;
import com.habitrpg.android.habitica.HabiticaApplication;
import com.habitrpg.android.habitica.HostConfig;
import com.habitrpg.android.habitica.ui.activities.AboutActivity;
import com.habitrpg.android.habitica.ui.activities.BaseActivity;
import com.habitrpg.android.habitica.ui.activities.IntroActivity;
import com.habitrpg.android.habitica.ui.activities.MainActivity;
import com.magicmicky.habitrpgwrapper.lib.models.Notification;
import com.magicmicky.habitrpgwrapper.lib.models.UserAuthResponse;
import com.magicmicky.habitrpgwrapper.lib.models.notifications.NotificationData;
import com.magicmicky.habitrpgwrapper.lib.models.responses.HabitResponse;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.robolectric.Robolectric;
import org.robolectric.RobolectricTestRunner;
import org.robolectric.Shadows;
import org.robolectric.annotation.Config;
import org.robolectric.shadows.ShadowAlertDialog;
import java.security.InvalidParameterException;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
import retrofit2.converter.gson.GsonConverterFactory;
import rx.observers.TestSubscriber;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
/**
* Created by krh12 on 12/9/2016.
@ -52,7 +37,7 @@ import static org.mockito.Mockito.when;
@RunWith(RobolectricTestRunner.class)
public class PopupNotificationsManagerTest {
public APIHelper apiHelper;
public IApiClient apiClient;
public HostConfig hostConfig;
public String username;
@ -65,13 +50,13 @@ public class PopupNotificationsManagerTest {
"",
"");
apiHelper = new APIHelper(APIHelper.createGsonFactory(), hostConfig);
apiClient = new ApiClient(ApiClient.createGsonFactory(), hostConfig);
}
@Test
public void itDoesNothingWhenNotificationsListIsEmpty() {
List<Notification> notifications = new ArrayList<>();
PopupNotificationsManager popupNotificationsManager = PopupNotificationsManager.getInstance(apiHelper);
PopupNotificationsManager popupNotificationsManager = PopupNotificationsManager.getInstance(apiClient);
popupNotificationsManager.showNotificationDialog(notifications);
AlertDialog alert =