org.robovm.apple.foundation.NSError Java Examples

/**
 * Loads and launches a store product view controller with a selected
 * product
 * 
 * @param tableView
 * @param indexPath
 */
@Override
public void didSelectRow(UITableView tableView, NSIndexPath indexPath) {
    Product item = myProducts.get(indexPath.getSection());

    // Create a product dictionary using the selected product's iTunes
    // identifer
    SKStoreProductParameters parameters = new SKStoreProductParameters().setITunesItemIdentifier(item
            .getProductID());

    // Attempt to load the selected product from the App Store, display the
    // store product view controller if success
    // and print an error message, otherwise.
    storeProductViewController.loadProduct(parameters, new VoidBlock2<Boolean, NSError>() {
        @Override
        public void invoke(Boolean result, NSError error) {
            if (result) {
                presentViewController(storeProductViewController, true, null);
            } else {
                System.err.println("Error message: " + error.getLocalizedDescription());
            }
        }
    });
}
 

@Override
public boolean deleteGameState(String fileId, final ISaveGameStateResponseListener success) {
    if (!isSessionActive())
        return false;

    GKLocalPlayer.getLocalPlayer().deleteSavedGames(fileId, new VoidBlock1<NSError>() {
        @Override
        public void invoke(NSError error) {
            if (success == null)
                return;

            if (error == null)
                success.onGameStateSaved(true, null);
            else
                success.onGameStateSaved(false, String.valueOf(error.getCode()));
        }
    });
    return true;
}
 

@Override
public boolean fetchGameStates(final IFetchGameStatesListResponseListener callback) {
    if (!isSessionActive())
        return false;

    GKLocalPlayer.getLocalPlayer().fetchSavedGames(new VoidBlock2<NSArray<GKSavedGame>, NSError>() {
        @Override
        public void invoke(NSArray<GKSavedGame> savedGames, NSError error) {
            if (error == null && savedGames != null) {
                Array<String> gameStates = new Array<String>(savedGames.size());

                for (GKSavedGame snapshot : savedGames) {
                    gameStates.add(snapshot.getName());
                }

                callback.onFetchGameStatesListResponse(gameStates);
            } else {
                callback.onFetchGameStatesListResponse(null);
            }
        }
    });
    return true;
}
 

public void logIn(final List<String> readPermissions, final LoginListener listener) {
    log("Trying to login with read permissions (%s)...", readPermissions);
    loginManager.logInWithReadPermissions(readPermissions,
            new VoidBlock2<FBSDKLoginManagerLoginResult, NSError>() {
                @Override
                public void invoke(FBSDKLoginManagerLoginResult result, NSError error) {
                    if (error != null) {
                        log("Failed to login: %s", error.getLocalizedDescription());
                        listener.onError("An unknown error happened!");
                    } else if (result.isCancelled()) {
                        log("Cancelled login!");
                        listener.onCancel();
                    } else {
                        if (!result.getGrantedPermissions().containsAll(readPermissions)) {
                            log("Failed to login: Permissions declined (%s)", result.getDeclinedPermissions());
                            listener.onError("The following permissions have been declined: "
                                    + result.getDeclinedPermissions().toString());
                        } else {
                            log("Successfully logged in!");
                            listener.onSuccess();
                        }
                    }
                }
            });
}
 

public void playerFinishedGame(int score, DifficultyLevel level, final ScoreSubmitCallback callback) {
    Leaderboard leaderboard = getLeaderboard(level);

    final GPGScore submitMe = GPGScore.getScore(leaderboard.getId());
    submitMe.setValue(score);

    submitMe.submitScore(new GPGScoreReportCallback() {
        @Override
        public void done(GPGScoreReport report, NSError error) {
            if (error != null) {
                Log.e("Received an error attempting to add to leaderboard %s: %s", submitMe, error);
                callback.onError(error);
            } else {
                if (report.isHighScoreForLocalPlayerToday()) {
                    Log.d("Woo hoo! Daily high score!");
                }
                callback.onSuccess(report);
            }
        }
    });
}
 

private void makeIncrementalProgress(Achievement achievement, int progressAmount) {
    Log.d("Your progress amount is %d", progressAmount);

    final GPGAchievement incrementMe = new GPGAchievement(achievement.getId());

    incrementMe.incrementSteps(progressAmount, new GPGAchievementIncrementStepsCallback() {
        @Override
        public void done(boolean newlyUnlocked, int currentSteps, NSError error) {
            if (error != null) {
                Log.e("Received an error attempting to increment achievement %s: %s", incrementMe, error);
            } else if (newlyUnlocked) {
                Log.d("Incremental achievement unlocked!");
            } else {
                Log.d("You've completed %d steps total", currentSteps);
            }
        }
    });
}
 

@Override
public void saveGameState(String fileId, byte[] gameState, long progressValue, final ISaveGameStateResponseListener success) {
       if (!isSessionActive()) {
           if (success != null)
               success.onGameStateSaved(false, "NOT_CONNECTED");
           return;
       }

       NSData nsData = new NSData(gameState);

       GKLocalPlayer.getLocalPlayer().saveGameData(nsData, fileId, new VoidBlock2<GKSavedGame, NSError>() {
           @Override
           public void invoke(GKSavedGame savedGame, NSError error) {
			if (success == null)
				return;

			if (error == null)
				success.onGameStateSaved(true, null);
			else {
				Gdx.app.log(GAMESERVICE_ID, "Could not save gamestate: " + error.getCode());
				success.onGameStateSaved(false, String.valueOf(error.getCode()));
			}
		}
       });
}
 

@Override
public boolean incrementAchievement(String achievementId, int incNum, float completionPercentage) {
	if (isSessionActive() && achievementId != null) {
		GKAchievement achievement = new GKAchievement(achievementId);
		achievement.setPercentComplete(completionPercentage * 100);
		achievement.setShowsCompletionBanner(true);
		// Create an array with the achievement
		NSArray<GKAchievement> achievements = new NSArray<>(achievement);
		GKAchievement.reportAchievements(achievements, new VoidBlock1<NSError>() {
			@Override
			public void invoke (NSError error) {
				// do nothing
			}
		});

		return true;
	}

	return false;
}
 

public void requestPublishPermissions(final List<String> publishPermissions, final LoginListener listener) {
    log("Requesting publish permissions (%s)...", publishPermissions);
    loginManager.logInWithPublishPermissions(publishPermissions,
            new VoidBlock2<FBSDKLoginManagerLoginResult, NSError>() {
                @Override
                public void invoke(FBSDKLoginManagerLoginResult result, NSError error) {
                    if (error != null) {
                        log("Failed to request publish permissions: %s", error);
                        listener.onError("An unknown error happened!");
                    } else if (result.isCancelled()) {
                        log("Cancelled request for publish permissions!");
                        listener.onCancel();
                    } else {
                        if (!result.getGrantedPermissions().containsAll(publishPermissions)) {
                            log("Failed to request publish permissions: Permissions declined (%s)",
                                    result.getDeclinedPermissions());
                            listener.onError("The following permissions have been declined: "
                                    + result.getDeclinedPermissions().toString());
                        } else {
                            log("Successfully requested publish permissions");
                            listener.onSuccess();
                        }
                    }
                }
            });
}
 

public void setFile(PFFile file) {
    final String requestURL = file.getUrl(); // Save copy of url locally
    url = file.getUrl(); // Save copy of url on the instance

    file.getDataInBackground(new PFGetDataCallback() {
        @Override
        public void done(NSData data, NSError error) {
            if (error == null) {
                UIImage image = new UIImage(data);
                if (requestURL.equals(url)) {
                    setImage(image);
                    setNeedsDisplay();
                }
            } else {
                Log.e("Error on fetching file: %s", error);
            }
        }
    });
}
 

@Override
public void didLoadObjects(NSError error) {
    super.didLoadObjects(error);

    if (getObjects().size() == 0 && !getQuery().hasCachedResult() && !firstLaunch) {
        getTableView().setScrollEnabled(false);

        if (blankTimelineView.getSuperview() == null) {
            blankTimelineView.setAlpha(0);
            getTableView().setTableHeaderView(blankTimelineView);

            UIView.animate(0.2, new Runnable() {
                @Override
                public void run() {
                    blankTimelineView.setAlpha(1);
                }
            });
        }
    } else {
        getTableView().setTableHeaderView(null);
        getTableView().setScrollEnabled(true);
    }
}
 

@Override
public void onClick(UIBarButtonItem barButtonItem) {
    UIActivityIndicatorView loadingActivityIndicatorView = new UIActivityIndicatorView(
            UIActivityIndicatorViewStyle.White);
    loadingActivityIndicatorView.startAnimating();
    getNavigationItem().setRightBarButtonItem(new UIBarButtonItem(loadingActivityIndicatorView));

    configureUnfollowButton();

    PAPUtility.followUserEventually(user, new PFSaveCallback() {
        @Override
        public void done(boolean success, NSError error) {
            if (error != null) {
                configureFollowButton();
            }
        }
    });
}
 

@Override
public void viewDidLoad() {
    super.viewDidLoad();

    FBSDKProfile.Notifications.observeCurrentProfileDidChange(new VoidBlock1<FBSDKProfileChangeNotification>() {
        @Override
        public void invoke(FBSDKProfileChangeNotification notification) {
            if (FBSDKProfile.getCurrentProfile() != null && PAPUser.getCurrentUser() != null) {
                PAPUser.getCurrentUser().fetchInBackground(new PFGetCallback<PAPUser>() {
                    @Override
                    public void done(PAPUser object, NSError error) {
                        refreshCurrentUser(object, error);
                    }
                });
            }
        }
    });
}
 

@Override
public boolean submitToLeaderboard(String leaderboardId, long score, String tag) {
	if (isSessionActive() && leaderboardId != null) {
		GKScore scoreReporter = new GKScore();
		scoreReporter.setValue(score);
		scoreReporter.setLeaderboardIdentifier(leaderboardId);
		NSArray<GKScore> scores = new NSArray<>(scoreReporter);
		GKScore.reportScores(scores, new VoidBlock1<NSError>() {
			@Override
			public void invoke (NSError error) {
				// ignore errors
			}
		});
		return true;
	}

	return false;
}
 

public void updateSubtitleIfNeeded() {
    if (subtitle == null) {
        // for the subtitle, we reverse geocode the lat/long for a proper
        // location string name
        CLLocation location = new CLLocation(coordinate.getLatitude(), coordinate.getLongitude());
        CLGeocoder geocoder = new CLGeocoder();
        geocoder.reverseGeocodeLocation(location, new VoidBlock2<NSArray<CLPlacemark>, NSError>() {
            @Override
            public void invoke(NSArray<CLPlacemark> placemarks, NSError error) {
                if (placemarks.size() > 0) {
                    CLPlacemark placemark = placemarks.get(0);
                    subtitle = String.format("Near %s", getStringForPlacemark(placemark));
                }
            }
        });
    }
}
 

/**
 * Prompt the user for access to their Address Book data
 */
private void requestAddressBookAccess() {
    addressBook.requestAccess(new ABAddressBook.RequestAccessCompletionHandler() {
        @Override
        public void requestAccess(boolean granted, NSError error) {
            if (granted) {
                DispatchQueue.getMainQueue().async(new Runnable() {
                    @Override
                    public void run() {
                        accessGrantedForAddressBook();
                    }
                });
            } else {
                checkAddressBookAccess();
            }
        }
    });
}
 

private void shouldNavigateToPhoto(PAPPhoto targetPhoto) {
    for (PAPPhoto photo : homeViewController.getObjects()) {
        if (photo.getObjectId().equals(targetPhoto.getObjectId())) {
            targetPhoto = photo;
            break;
        }
    }

    // if we have a local copy of this photo, this won't result in a network
    // fetch
    targetPhoto.fetchIfNeededInBackground(new PFGetCallback<PAPPhoto>() {
        @Override
        public void done(PAPPhoto object, NSError error) {
            if (error == null) {
                UINavigationController homeNavigationController = tabBarController.getHomeNavigationController();
                tabBarController.setSelectedViewController(homeNavigationController);

                PAPPhotoDetailsViewController detailViewController = new PAPPhotoDetailsViewController(object);
                homeNavigationController.pushViewController(detailViewController, true);
            }
        }
    });
}
 

public static void unfollowUsersEventually(List<PAPUser> users) {
    PFQuery<PAPActivity> query = PFQuery.getQuery(PAPActivity.class);
    query.whereEqualTo(PAPActivity.FROM_USER_KEY, PAPUser.getCurrentUser());
    query.whereContainedIn(PAPActivity.TO_USER_KEY, new NSArray<PAPUser>(users));
    query.whereEqualTo(PAPActivity.TYPE_KEY, PAPActivityType.FOLLOW.getKey());
    query.findInBackground(new PFFindCallback<PAPActivity>() {
        @Override
        public void done(NSArray<PAPActivity> activities, NSError error) {
            for (PAPActivity activity : activities) {
                activity.deleteEventually();
            }
        }
    });
    for (PAPUser user : users) {
        PAPCache.getSharedCache().setUserFollowStatus(user, false);
    }
}
 

public static void unfollowUserEventually(PAPUser user) {
    PFQuery<PAPActivity> query = PFQuery.getQuery(PAPActivity.class);
    query.whereEqualTo(PAPActivity.FROM_USER_KEY, PAPUser.getCurrentUser());
    query.whereEqualTo(PAPActivity.TO_USER_KEY, user);
    query.whereEqualTo(PAPActivity.TYPE_KEY, PAPActivityType.FOLLOW.getKey());
    query.findInBackground(new PFFindCallback<PAPActivity>() {
        @Override
        public void done(NSArray<PAPActivity> activities, NSError error) {
            // While normally there should only be one follow activity
            // returned, we can't guarantee that.
            if (error == null) {
                for (PAPActivity activity : activities) {
                    activity.deleteEventually();
                }
            }
        }
    });
    PAPCache.getSharedCache().setUserFollowStatus(user, false);
}
 

private void shouldDeletePhoto() {
    // Delete all activites related to this photo
    PFQuery<PAPActivity> query = PFQuery.getQuery(PAPActivity.class);
    query.whereEqualTo(PAPActivity.PHOTO_KEY, photo);
    query.findInBackground(new PFFindCallback<PAPActivity>() {
        @Override
        public void done(NSArray<PAPActivity> objects, NSError error) {
            if (error == null) {
                for (PAPActivity activity : objects) {
                    activity.deleteEventually();
                }
            }

            // Delete photo
            photo.deleteEventually();
        }
    });
    PAPNotificationManager.postNotification(PAPNotification.USER_DELETED_PHOTO, photo.getObjectId());
    getNavigationController().popViewController(true);
}
 

@Override
        public void onClick(UIBarButtonItem barButtonItem) {
            if (photo.getPicture().isDataAvailable()) {
                showShareSheet();
            } else {
//        [MBProgressHUD showHUDAddedTo:self.view animated:YES]; TODO
                photo.getPicture().getDataInBackground(new PFGetDataCallback() {
                    @Override
                    public void done(NSData data, NSError error) {
//            [MBProgressHUD hideHUDForView:self.view animated:YES]; TODO
                        if (error == null) {
                            showShareSheet();
                        }
                    }
                });
            }
        }
 

private void processedFacebookResponse() {
    // Once we handled all necessary facebook batch responses, save
    // everything necessary and continue
    synchronized (this) {
        facebookResponseCount++;
        if (facebookResponseCount != expectedFacebookResponseCount) {
            return;
        }
    }
    facebookResponseCount = 0;
    Log.d("done processing all Facebook requests");

    PAPUser.getCurrentUser().saveInBackground(new PFSaveCallback() {
        @Override
        public void done(boolean success, NSError error) {
            if (!success) {
                Log.e("Failed save in background of user, %s", error);
            } else {
                Log.d("saved current parse user");
            }
        }
    });
}
 

@Override
public void viewWillAppear(boolean animated) {
    super.viewWillAppear(animated);

    if (PAPUser.getCurrentUser() == null) {
        presentLoginViewController(false);
        return;
    }

    // Present Anypic UI
    ((AnyPicApp) UIApplication.getSharedApplication().getDelegate()).presentTabBarController();

    // Refresh current user with server side data -- checks if user is still
    // valid and so on
    facebookResponseCount = 0;
    PAPUser.getCurrentUser().fetchInBackground(new PFGetCallback<PAPUser>() {
        @Override
        public void done(PAPUser object, NSError error) {
            if (FBSDKProfile.getCurrentProfile() != null) {
                refreshCurrentUser(object, error);
            }
        }
    });
}
 

private void shouldToggleFollowFriendForCell(final PAPFindFriendsCell cell) {
    PAPUser cellUser = cell.getUser();
    if (cell.getFollowButton().isSelected()) {
        // Unfollow
        cell.getFollowButton().setSelected(false);
        PAPUtility.unfollowUserEventually(cellUser);
        PAPNotificationManager.postNotification(PAPNotification.USER_FOLLOWING_CHANGED);
    } else {
        // Follow
        cell.getFollowButton().setSelected(true);
        PAPUtility.followUserEventually(cellUser, new PFSaveCallback() {
            @Override
            public void done(boolean success, NSError error) {
                if (error == null) {
                    PAPNotificationManager.postNotification(PAPNotification.USER_FOLLOWING_CHANGED);
                } else {
                    cell.getFollowButton().setSelected(false);
                }
            }
        });
    }
}
 

@Override
public void didLoadObjects(NSError error) {
    super.didLoadObjects(error);

    headerView.reloadLikeBar();
    loadLikers();
}
 

private void cancelLogIn(NSError error) {
        if (error != null) {
            handleLogInError(error);
        }
//  [self.hud removeFromSuperview]; TODO
        PFFacebookUtils.getFacebookLoginManager().logOut();
        PFUser.logOut();
        ((AnyPicApp) UIApplication.getSharedApplication().getDelegate()).presentLoginViewController(false);
    }
 

private void handleLogIn(FBSDKLoginManagerLoginResult result) {
        if (!result.isCancelled() && result.getToken() != null) {
            if (PAPUser.getCurrentUser() != null) {
                if (delegate != null) {
                    delegate.didLogin(this);
                }
                return;
            }

            FBSDKAccessToken accessToken = FBSDKAccessToken.getCurrentAccessToken();
            String facebookUserId = accessToken.getUserID();

            if (accessToken == null || facebookUserId == null) {
                Log.e("Login failure. FB Access Token or user ID does not exist");
                return;
            }

//                self.hud = [MBProgressHUD showHUDAddedTo:self.view animated:YES]; TODO

            PFFacebookUtils.logInInBackground(accessToken, new PFLogInCallback() {
                @Override
                public void done(PFUser user, NSError error) {
                    if (error == null) {
//                        [self.hud removeFromSuperview]; TODO
                        if (delegate != null) {
                            delegate.didLogin(PAPLoginViewController.this);
                        }
                    } else {
                        cancelLogIn(error);
                    }
                }
            });
        }
    }
 

private void showShareSheet() {
    photo.getPicture().getDataInBackground(new PFGetDataCallback() {
        @Override
        public void done(NSData data, NSError error) {
            if (error == null) {
                List<Object> activityItems = new ArrayList<>(3);

                NSArray<PAPActivity> activities = getObjects();

                // Prefill caption if this is the original poster of the
                // photo, and then only if they added a caption initially.
                if (PAPUser.getCurrentUser().getObjectId().equals(photo.getUser().getObjectId())
                        && activities.size() > 0) {
                    PAPActivity firstActivity = activities.first();
                    if (firstActivity.getFromUser().getObjectId().equals(photo.getUser().getObjectId())) {
                        String commentString = firstActivity.getContent();
                        activityItems.add(commentString);
                    }
                }

                activityItems.add(new UIImage(data));
                activityItems.add(new NSURL(String.format("https://anypic.org/#pic/%s", photo.getObjectId())));

                UIActivityViewController activityViewController = new UIActivityViewController(activityItems, null);
                getNavigationController().presentViewController(activityViewController, true, null);
            }
        }
    });
}
 

public void autoFollowUsers() {
        firstLaunch = true;
        PFCloud.callFunctionInBackground("autoFollowUsers", null, new PFFunctionCallback<PFObject>() {
            @Override
            public void done(PFObject result, NSError error) {
                if (error != null) {
                    Log.e("Error auto following users: %s", error);
                }
//                [MBProgressHUD hideHUDForView:self.navController.presentedViewController.view animated:NO]; TODO
                homeViewController.loadObjects();
            }
        });
    }
 

@Override
public boolean resumeSession() {
	if (!handlerSet) {
		connecting = true;
		handlerSet = true;
		final GKLocalPlayer localPlayer = GKLocalPlayer.getLocalPlayer();
		localPlayer.setAuthenticateHandler(new VoidBlock2<UIViewController, NSError>() {
			@Override
			public void invoke(UIViewController gkViewController, NSError nsError) {
				connecting = false;

				if (isSessionActive()) {
					lastGotLoginScreen = null;
					Gdx.app.debug(GAMESERVICE_ID, "Successfully logged into GameCenter");
					if (gsListener != null) {
						gsListener.gsOnSessionActive();
					}
				} else {
					if (gkViewController != null)
						lastGotLoginScreen = gkViewController;
					Gdx.app.debug(GAMESERVICE_ID, "Did not authenticate.");
					if (gsListener != null)
						gsListener.gsOnSessionInactive();
					if (callLoginFromHandler)
						logIn();
				}
			}
		});
	}
	return isSessionActive() || isConnectionPending();
}