@Override public void userStartedBroadcasting(User user, Stream stream) { List<User> friends = this.friendshipService.findAllFriendsOfUser(user.getId()); for (User userToNotify : friends) { if (userToNotify == null || userToNotify.getAccount() == null || !StringUtils.hasText(userToNotify.getAccount().getPushNotificationID())) { continue; } if (ObjectUtils.nullSafeEquals(user, userToNotify)) { // do not notify current user continue; } final ParseRequest request = new ParseRequest(); IOSNotification iosNotification = new IOSNotification(NotificationType.BROADCAST_STARTED); iosNotification.setUserId(user.getId()); iosNotification.setUserName(user.getUserName()); iosNotification.setAlert(stream.getText()); iosNotification.setBadge("Increment"); iosNotification.setCategory("pass_watch"); final ParseQuery query = new ParseQuery(userToNotify.getAccount().getPushNotificationID()); request.setWhere(query); request.setData(iosNotification); try { HttpEntity<ParseRequest> requestEntity = new HttpEntity<ParseRequest>(request); ParseResponse response = this.parseRestTemplate.postForObject( PARSE_POST_PUSH_URL, requestEntity, ParseResponse.class); if (response.getError() != null) { System.out.println("PARSE PUSH NOTIFICATIOn ERROR: " + response.getError()); } } catch (Exception e) { log.error("Error while sending notification to Parse for iOS clients", e); } } }
/** * Returns the unsigned {@code int} value represented by the given string. * * <p>Accepts a decimal, hexadecimal, or octal number given by specifying the following prefix: * * <ul> * <li>{@code 0x}<i>HexDigits</i> * <li>{@code 0X}<i>HexDigits</i> * <li>{@code #}<i>HexDigits</i> * <li>{@code 0}<i>OctalDigits</i> * </ul> * * @throws NumberFormatException if the string does not contain a valid unsigned {@code int} value * @since 13.0 */ public static int decode(String stringValue) { ParseRequest request = ParseRequest.fromString(stringValue); try { return parseUnsignedInt(request.rawValue, request.radix); } catch (NumberFormatException e) { NumberFormatException decodeException = new NumberFormatException("Error parsing value: " + stringValue); decodeException.initCause(e); throw decodeException; } }
@SuppressWarnings("ThrowableResultOfMethodCallIgnored") public void test4XXThrowsException() throws Exception { ParseRequest.setDefaultInitialRetryDelay(1L); InputStream mockInputStream = new ByteArrayInputStream("An Error occurred while saving".getBytes()); ParseHttpResponse mockResponse = mock(ParseHttpResponse.class); when(mockResponse.getStatusCode()).thenReturn(400); when(mockResponse.getTotalSize()).thenReturn(0L); when(mockResponse.getReasonPhrase()).thenReturn("Bad Request"); when(mockResponse.getContent()).thenReturn(mockInputStream); ParseHttpClient mockHttpClient = mock(ParseHttpClient.class); when(mockHttpClient.execute(any(ParseHttpRequest.class))).thenReturn(mockResponse); ParseAWSRequest request = new ParseAWSRequest(ParseHttpRequest.Method.GET, "http://parse.com"); Task<byte[]> task = request.executeAsync(mockHttpClient); task.waitForCompletion(); assertTrue(task.isFaulted()); assertTrue(task.getError() instanceof ParseException); ParseException error = (ParseException) task.getError(); assertEquals(error.getCode(), ParseException.CONNECTION_FAILED); assertTrue(error.getMessage().contains("Download from S3")); }
@Override protected void tearDown() throws Exception { ParseRequest.setDefaultInitialRetryDelay(ParseRequest.DEFAULT_INITIAL_RETRY_DELAY); super.tearDown(); }
/** * Authenticates this client as belonging to your application. * * <p>This method is only required if you intend to use a different {@code applicationId} or * {@code clientKey} than is defined by {@code com.parse.APPLICATION_ID} or {@code * com.parse.CLIENT_KEY} in your {@code AndroidManifest.xml}. * * <p>This must be called before your application can use the Parse library. The recommended way * is to put a call to {@code Parse.initialize} in your {@code Application}'s {@code onCreate} * method: * * <p> * * <pre> * public class MyApplication extends Application { * public void onCreate() { * Parse.initialize(this, "your application id", "your client key"); * } * } * </pre> * * @param context The active {@link Context} for your application. * @param applicationId The application id provided in the Parse dashboard. * @param clientKey The client key provided in the Parse dashboard. */ public static void initialize(Context context, String applicationId, String clientKey) { ParsePlugins.Android.initialize(context, applicationId, clientKey); Context applicationContext = context.getApplicationContext(); ParseHttpClient.setKeepAlive(true); ParseHttpClient.setMaxConnections(20); ParseRequest.setDefaultClient(ParsePlugins.get().restClient()); // If we have interceptors in list, we have to initialize all http clients and add interceptors if (interceptors != null) { initializeParseHttpClientsWithParseNetworkInterceptors(); } ParseObject.registerParseSubclasses(); if (isLocalDatastoreEnabled()) { offlineStore = new OfflineStore(context); } else { ParseKeyValueCache.initialize(context); } // Make sure the data on disk for Parse is for the current // application. checkCacheApplicationId(); new Thread("Parse.initialize Disk Check & Starting Command Cache") { @Override public void run() { // Trigger the command cache to flush its contents. getEventuallyQueue(); } }.start(); ParseFieldOperations.registerDefaultDecoders(); if (!allParsePushIntentReceiversInternal()) { throw new SecurityException( "To prevent external tampering to your app's notifications, " + "all receivers registered to handle the following actions must have " + "their exported attributes set to false: com.parse.push.intent.RECEIVE, " + "com.parse.push.intent.OPEN, com.parse.push.intent.DELETE"); } // May need to update GCM registration ID if app version has changed. // This also primes current installation. GcmRegistrar.getInstance() .registerAsync() .continueWithTask( new Continuation<Void, Task<Void>>() { @Override public Task<Void> then(Task<Void> task) throws Exception { // Prime current user in the background return ParseUser.getCurrentUserAsync().makeVoid(); } }) .continueWith( new Continuation<Void, Void>() { @Override public Void then(Task<Void> task) throws Exception { // Prime config in the background ParseConfig.getCurrentConfig(); return null; } }, Task.BACKGROUND_EXECUTOR); if (ManifestInfo.getPushType() == PushType.PPNS) { PushService.startServiceIfRequired(applicationContext); } dispatchOnParseInitialized(); // FYI we probably don't want to do this if we ever add other callbacks. synchronized (MUTEX_CALLBACKS) { Parse.callbacks = null; } }
public List<TaggedPositionRegion<TokenTag<Token>>> getHighlights(int startOffset, int endOffset) { List<TaggedPositionRegion<TokenTag<Token>>> tags = new ArrayList<>(); boolean updateOffsets = true; if (endOffset == Integer.MAX_VALUE) { endOffset = snapshot.length(); } OffsetRegion span = OffsetRegion.fromBounds(startOffset, endOffset); if (failedTimeout) { return tags; } boolean spanExtended = false; int extendMultiLineSpanToLine = 0; OffsetRegion extendedSpan = span; synchronized (lock) { OffsetRegion requestedSpan = span; ParseRequest<TState> request = adjustParseSpan(span); TState startState = request.getState(); span = request.getRegion(); CharStream input; try { input = createInputStream(span); } catch (BadLocationException ex) { LOGGER.log(Level.WARNING, ex.getMessage(), ex); return tags; } TokenSourceWithStateV4<TState> lexer = createLexer(input, startState); lexer.setTokenFactory(new DocumentSnapshotTokenFactory(getEffectiveTokenSource(lexer))); Token previousToken = null; boolean previousTokenEndsLine = false; /* this is held outside the loop because only tokens which end at the end of a line * impact its value. */ boolean lineStateChanged = false; while (true) { // TODO: perform this under a read lock Token token = lexer.nextToken(); // The latter is true for EOF token with span.getEnd() at the end of the document boolean inBounds = token.getStartIndex() < span.getEnd() || token.getStopIndex() < span.getEnd(); if (updateOffsets) { int startLineCurrent; if (token.getType() == Token.EOF) startLineCurrent = snapshot.getLineCount(); else startLineCurrent = snapshot.findLineNumber(token.getStartIndex()); // endLinePrevious is the line number the previous token ended on int endLinePrevious; if (previousToken != null) endLinePrevious = snapshot.findLineNumber(previousToken.getStopIndex() + 1); else endLinePrevious = snapshot.findLineNumber(span.getStart()) - 1; if (startLineCurrent > endLinePrevious + 1 || (startLineCurrent == endLinePrevious + 1 && !previousTokenEndsLine)) { int firstMultilineLine = endLinePrevious; if (previousToken == null || previousTokenEndsLine) firstMultilineLine++; for (int i = firstMultilineLine; i < startLineCurrent; i++) { if (!lineStates.get(i).getIsMultiLineToken() || lineStateChanged) extendMultiLineSpanToLine = i + 1; if (inBounds) setLineState(i, lineStates.get(i).createMultiLineState()); } } } if (token.getType() == Token.EOF) break; if (updateOffsets && isMultiLineToken(lexer, token)) { int startLine = snapshot.findLineNumber(token.getStartIndex()); int stopLine = snapshot.findLineNumber(token.getStopIndex() + 1); for (int i = startLine; i < stopLine; i++) { if (!lineStates.get(i).getIsMultiLineToken()) extendMultiLineSpanToLine = i + 1; if (inBounds) setLineState(i, lineStates.get(i).createMultiLineState()); } } boolean tokenEndsLine = tokenEndsAtEndOfLine(lexer, token); if (updateOffsets && tokenEndsLine) { TState stateAtEndOfLine = lexer.getCurrentState(); int line = snapshot.findLineNumber(token.getStopIndex() + 1); lineStateChanged = lineStates.get(line).getIsMultiLineToken() || !lineStates.get(line).equals(stateAtEndOfLine); // even if the state didn't change, we call SetLineState to make sure the // _first/_lastChangedLine values get updated. // have to check bounds for this one or the editor might not get an update (if the token // ends a line) if (updateOffsets && inBounds) setLineState(line, stateAtEndOfLine); if (lineStateChanged) { if (line < snapshot.getLineCount() - 1) { /* update the span's end position or the line state change won't be reflected * in the editor */ int endPosition = line < snapshot.getLineCount() - 2 ? snapshot.findLineFromLineNumber(line + 2).getStart().getOffset() : snapshot.length(); if (endPosition > extendedSpan.getEnd()) { spanExtended = true; extendedSpan = OffsetRegion.fromBounds(extendedSpan.getStart(), endPosition); } } } } if (token.getStartIndex() >= span.getEnd()) { break; } previousToken = token; previousTokenEndsLine = tokenEndsLine; if (token.getStopIndex() < requestedSpan.getStart()) { continue; } Collection<TaggedPositionRegion<TokenTag<Token>>> tokenClassificationSpans = getTagsForToken(token); if (tokenClassificationSpans != null) { tags.addAll(tokenClassificationSpans); } if (!inBounds) { break; } } } if (updateOffsets && extendMultiLineSpanToLine > 0) { int endPosition = extendMultiLineSpanToLine < snapshot.getLineCount() - 1 ? snapshot .findLineFromLineNumber(extendMultiLineSpanToLine + 1) .getStart() .getOffset() : snapshot.length(); if (endPosition > extendedSpan.getEnd()) { spanExtended = true; extendedSpan = OffsetRegion.fromBounds(extendedSpan.getStart(), endPosition); } } if (updateOffsets && spanExtended) { /* Subtract 1 from each of these because the spans include the line break on their last * line, forcing it to appear as the first position on the following line. */ assert extendedSpan.getEnd() > span.getEnd(); int firstLine = snapshot.findLineNumber(span.getEnd()); int lastLine = snapshot.findLineNumber(extendedSpan.getEnd()) - 1; // when considering the last line of a document, span and extendedSpan may end on the same // line forceRehighlightLines(firstLine, Math.max(firstLine, lastLine)); } return tags; }