private static void populateUser() { try { user.put("name", Preferences.getStringValue(PREF_NAME)); user.put("first_name", Preferences.getStringValue(PREF_FIRST_NAME)); user.put("last_name", Preferences.getStringValue(PREF_LAST_NAME)); user.put("premium", isPremiumUser()); user.put("email", Preferences.getStringValue(PREF_EMAIL)); user.put("picture", Preferences.getStringValue(PREF_PICTURE)); user.put("id", ActFmPreferenceService.userId()); } catch (JSONException e) { throw new RuntimeException(e); } }
@SuppressWarnings("nls") private void refreshMembersPage() { tagName.setText(tagData.getValue(TagData.NAME)); picture.setUrl(tagData.getValue(TagData.PICTURE)); TextView ownerLabel = (TextView) findViewById(R.id.tag_owner); try { if (tagData.getFlag(TagData.FLAGS, TagData.FLAG_EMERGENT)) { ownerLabel.setText(String.format("<%s>", getString(R.string.actfm_TVA_tag_owner_none))); } else if (tagData.getValue(TagData.USER_ID) == 0) { ownerLabel.setText(Preferences.getStringValue(ActFmPreferenceService.PREF_NAME)); } else { JSONObject owner = new JSONObject(tagData.getValue(TagData.USER)); ownerLabel.setText(owner.getString("name")); } } catch (JSONException e) { Log.e("tag-view-activity", "json error refresh owner", e); ownerLabel.setText("<error>"); System.err.println(tagData.getValue(TagData.USER)); } tagMembers.removeAllViews(); String peopleJson = tagData.getValue(TagData.MEMBERS); if (!TextUtils.isEmpty(peopleJson)) { try { JSONArray people = new JSONArray(peopleJson); for (int i = 0; i < people.length(); i++) { JSONObject person = people.getJSONObject(i); TextView textView = null; if (person.has("id") && person.getLong("id") == ActFmPreferenceService.userId()) textView = tagMembers.addPerson(Preferences.getStringValue(ActFmPreferenceService.PREF_NAME)); else if (!TextUtils.isEmpty(person.optString("name"))) textView = tagMembers.addPerson(person.getString("name")); else if (!TextUtils.isEmpty(person.optString("email"))) textView = tagMembers.addPerson(person.getString("email")); if (textView != null) { textView.setTag(person); textView.setEnabled(false); } } } catch (JSONException e) { System.err.println(peopleJson); Log.e("tag-view-activity", "json error refresh members", e); } } tagMembers.addPerson(""); // $NON-NLS-1$ }
private Filter getFilter(int widgetId) { // base our filter off the inbox filter, replace stuff if we have it Filter filter = CoreFilterExposer.buildInboxFilter(getResources()); String sql = Preferences.getStringValue(WidgetConfigActivity.PREF_SQL + widgetId); if (sql != null) filter.sqlQuery = sql; String title = Preferences.getStringValue(WidgetConfigActivity.PREF_TITLE + widgetId); if (title != null) filter.title = title; String contentValues = Preferences.getStringValue(WidgetConfigActivity.PREF_VALUES + widgetId); if (contentValues != null) filter.valuesForNewTasks = AndroidUtilities.contentValuesFromSerializedString(contentValues); return filter; }
@SuppressWarnings("nls") private static synchronized JSONObject thisUser() { if (user == null) { user = new JSONObject(); try { user.put("name", Preferences.getStringValue(PREF_NAME)); user.put("email", Preferences.getStringValue(PREF_EMAIL)); user.put("picture", Preferences.getStringValue(PREF_PICTURE)); user.put("id", Preferences.getLong(PREF_USER_ID, 0)); System.err.println(user); } catch (JSONException e) { throw new RuntimeException(e); } } return user; }
/** * Invalidates and then revalidates the auth token for the currently logged in user Shouldn't be * called from the main thread--will block on network calls * * @return valid token on success, null on failure */ public static synchronized String validateAuthToken(Context c, String token) throws GoogleTasksException { GoogleAccountManager accountManager = new GoogleAccountManager(ContextManager.getContext()); if (testToken(token)) { return token; } // If fail, token may have expired -- get a new one and return that String accountName = Preferences.getStringValue(GtasksPreferenceService.PREF_USER_NAME); Account a = accountManager.getAccountByName(accountName); if (a == null) { throw new GoogleTasksException( c.getString(R.string.gtasks_error_accountNotFound, accountName), "account-not-found"); } for (int i = 0; i < REVALIDATION_TRIES; i++) { accountManager.invalidateAuthToken(token); // try with notify-auth-failure = false AccountManagerFuture<Bundle> future = accountManager.manager.getAuthToken(a, GtasksInvoker.AUTH_TOKEN_TYPE, false, null, null); token = getTokenFromFuture(c, future); if (TOKEN_INTENT_RECEIVED.equals(token)) { return null; } else if (token != null && testToken(token)) { return token; } } throw new GoogleTasksException( c.getString(R.string.gtasks_error_authRefresh), "auth-token-refresh"); }
/** * Migration for existing users to assert that the "hide always" section divider exists in the * preferences. Knowing that this section will always be in the constructed list of controls * simplifies the logic a bit. * * @param c */ public static void assertHideUntilSectionExists(Context c, long latestSetVersion) { if (latestSetVersion == 0) Preferences.setBoolean(BEAST_MODE_ASSERTED_HIDE_ALWAYS, true); if (Preferences.getBoolean(BEAST_MODE_ASSERTED_HIDE_ALWAYS, false)) return; String order = Preferences.getStringValue(BEAST_MODE_ORDER_PREF); String hideSectionPref = c.getString(R.string.TEA_ctrl_hide_section_pref); if (TextUtils.isEmpty(order)) { // create preference and stick hide always at the end of it String[] items = c.getResources().getStringArray(R.array.TEA_control_sets_prefs); StringBuilder builder = new StringBuilder(); for (String item : items) { if (item.equals(hideSectionPref)) continue; builder.append(item); builder.append(BEAST_MODE_PREF_ITEM_SEPARATOR); } builder.append(hideSectionPref); builder.append(BEAST_MODE_PREF_ITEM_SEPARATOR); order = builder.toString(); } else if (!order.contains(hideSectionPref)) { order += (hideSectionPref + BEAST_MODE_PREF_ITEM_SEPARATOR); } Preferences.setString(BEAST_MODE_ORDER_PREF, order); Preferences.setBoolean(BEAST_MODE_ASSERTED_HIDE_ALWAYS, true); }
/** @return get user id */ public static String userId() { try { String value = Preferences.getStringValue(PREF_USER_ID); if (value == null) { return Long.toString(Preferences.getLong(PREF_USER_ID, -2L)); } return value; } catch (Exception e) { return Long.toString(Preferences.getLong(PREF_USER_ID, -2L)); } }
@Override public String getLoggedInUserName() { String name = Preferences.getStringValue(PREF_NAME); if (TextUtils.isEmpty(name)) { String firstName = Preferences.getStringValue(PREF_FIRST_NAME); if (!TextUtils.isEmpty(firstName)) { name = firstName; } String lastName = Preferences.getStringValue(PREF_FIRST_NAME); if (!TextUtils.isEmpty(lastName)) { if (!TextUtils.isEmpty(name)) { name += " "; // $NON-NLS-1$ } name += lastName; } if (name == null) { name = ""; // $NON-NLS-1$ } } return name; }
public static ArrayList<String> constructOrderedControlList(Context context) { String order = Preferences.getStringValue(BEAST_MODE_ORDER_PREF); ArrayList<String> list = new ArrayList<String>(); String[] itemsArray; if (order == null) { itemsArray = context.getResources().getStringArray(R.array.TEA_control_sets_prefs); } else { itemsArray = order.split(BEAST_MODE_PREF_ITEM_SEPARATOR); } for (String s : itemsArray) { if (!s.equals(context.getResources().getString(R.string.TEA_ctrl_title_pref))) { list.add(s); } } if (order == null) return list; itemsArray = context.getResources().getStringArray(R.array.TEA_control_sets_prefs); for (int i = 0; i < itemsArray.length; i++) { if (!list.contains(itemsArray[i])) list.add(i, itemsArray[i]); } return list; }
private String getQuery(Context context) { if (SubtasksHelper.isTagFilter(filter)) { ((FilterWithCustomIntent) filter).customTaskList = new ComponentName( context, TagViewFragment.class); // In case legacy widget was created with subtasks fragment } SharedPreferences publicPrefs = AstridPreferences.getPublicPrefs(context); int flags = publicPrefs.getInt(SortHelper.PREF_SORT_FLAGS, 0); flags |= SortHelper.FLAG_SHOW_RECENTLY_COMPLETED; int sort = publicPrefs.getInt(SortHelper.PREF_SORT_SORT, 0); if (sort == 0) { sort = SortHelper.SORT_WIDGET; } String query = SortHelper.adjustQueryForFlagsAndSort(filter.getSqlQuery(), flags, sort) .replaceAll("LIMIT \\d+", ""); String tagName = Preferences.getStringValue(WidgetConfigActivity.PREF_TITLE + widgetId); return SubtasksHelper.applySubtasksToWidgetFilter(filter, query, tagName, 0); }
@Override public void onReceive(final Context context, Intent intent) { if (!Preferences.getBoolean(R.string.p_field_missed_calls, false)) { Preferences.clear(PREF_LAST_INCOMING_NUMBER); return; } String state = intent.getStringExtra(TelephonyManager.EXTRA_STATE); if (TelephonyManager.EXTRA_STATE_RINGING.equals(state)) { String number = digitsOnly(intent.getStringExtra(TelephonyManager.EXTRA_INCOMING_NUMBER)); if (TextUtils.isEmpty(number)) return; Preferences.setString(PREF_LAST_INCOMING_NUMBER, number); } else if (TelephonyManager.EXTRA_STATE_IDLE.equals(state)) { final String lastNumber = Preferences.getStringValue(PREF_LAST_INCOMING_NUMBER); if (TextUtils.isEmpty(lastNumber)) { return; } Preferences.clear(PREF_LAST_INCOMING_NUMBER); new Thread() { @Override public void run() { AndroidUtilities.sleepDeep(WAIT_BEFORE_READ_LOG); Cursor calls = context .getContentResolver() .query( Calls.CONTENT_URI, new String[] {Calls.NUMBER, Calls.DATE, Calls.CACHED_NAME}, Calls.TYPE + " = ? AND " + Calls.NEW + " = ?", new String[] {Integer.toString(Calls.MISSED_TYPE), "1"}, Calls.DATE + " DESC"); try { if (calls == null) return; if (calls.moveToFirst()) { int numberIndex = calls.getColumnIndex(Calls.NUMBER); String number = calls.getString(numberIndex); // Sanity check for phone number match // in case the phone logs haven't updated for some reaosn if (!lastNumber.equals(digitsOnly(number))) { return; } // If a lot of time has passed since the most recent missed call, ignore // It could be the same person calling you back before you call them back, // but if you answer this time, the missed call will still be in the database // and will be processed again. int dateIndex = calls.getColumnIndex(Calls.DATE); long date = calls.getLong(dateIndex); if (DateUtilities.now() - date > 2 * DateUtilities.ONE_MINUTE) { return; } int nameIndex = calls.getColumnIndex(Calls.CACHED_NAME); String name = calls.getString(nameIndex); String timeString = DateUtilities.getTimeString(context, new Date(date)); long contactId = getContactIdFromNumber(context, number); Intent missedCallIntent = new Intent(context, MissedCallActivity.class); missedCallIntent.putExtra(MissedCallActivity.EXTRA_NUMBER, number); missedCallIntent.putExtra(MissedCallActivity.EXTRA_NAME, name); missedCallIntent.putExtra(MissedCallActivity.EXTRA_TIME, timeString); missedCallIntent.putExtra(MissedCallActivity.EXTRA_CONTACT_ID, contactId); missedCallIntent.setFlags( Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_MULTIPLE_TASK); context.startActivity(missedCallIntent); } } finally { if (calls != null) calls.close(); } } }.start(); } }
public void checkAndMigrateLegacy() throws IOException { if (!gtasksPreferenceService.migrationHasOccurred()) { // Fetch all tasks that have associated gtask metadata String defaultListTitle = gtasksListService.getListName( Preferences.getStringValue(GtasksPreferenceService.PREF_DEFAULT_LIST)); String defaultListId = null; TodorooCursor<Task> allTasksWithGtaskData = taskService.query( Query.select(Task.PROPERTIES) .where( Task.ID.in( Query.select(Metadata.TASK) .from(Metadata.TABLE) .where(Metadata.KEY.eq(GtasksMetadata.METADATA_KEY))))); try { if (allTasksWithGtaskData.getCount() > 0) { // Fetch all remote tasks from all remote lists (this may be an expensive operation) // and map their titles to their real remote ids HashMap<String, String> taskAndListTitlesToRemoteTaskIds = new HashMap<String, String>(); List<TaskList> items = allLists.getItems(); for (TaskList list : items) { if (list.getTitle().equals(defaultListTitle)) { defaultListId = list.getId(); } Tasks allTasks = gtasksService.getAllGtasksFromListId(list.getId(), false, false, 0); List<com.google.api.services.tasks.model.Task> tasksItems = allTasks.getItems(); if (tasksItems != null) { for (com.google.api.services.tasks.model.Task t : tasksItems) { String key = constructKeyFromTitles(t.getTitle(), list.getTitle()); taskAndListTitlesToRemoteTaskIds.put(key, t.getId()); } } } if (defaultListId == null) { com.google.api.services.tasks.model.TaskList defaultList = gtasksService.getGtaskList("@default"); // $NON-NLS-1$ defaultListId = defaultList.getId(); } Preferences.setString(GtasksPreferenceService.PREF_DEFAULT_LIST, defaultListId); // For each local task, check to see if its title paired with any list title has a match // in the map for (allTasksWithGtaskData.moveToFirst(); !allTasksWithGtaskData.isAfterLast(); allTasksWithGtaskData.moveToNext()) { GtasksTaskContainer container = gtasksMetadataService.readTaskAndMetadata(allTasksWithGtaskData); // memorize the original listname for the case that the task is not matched, // then it should at least be recreated in the correct list String originalListName = gtasksListService.getListName( container.gtaskMetadata.getValue(GtasksMetadata.LIST_ID)); String originalListId = null; // Search through lists to see if one of them has match String taskTitle = container.task.getValue(Task.TITLE); boolean foundMatch = false; items = allLists.getItems(); for (TaskList list : items) { String expectedKey = constructKeyFromTitles(taskTitle, list.getTitle()); // save the new id of the current list // if it matches the listname of the current task if (list.getTitle() != null && list.getTitle().equals(originalListName)) { originalListId = list.getId(); } if (taskAndListTitlesToRemoteTaskIds.containsKey(expectedKey)) { foundMatch = true; String newRemoteTaskId = taskAndListTitlesToRemoteTaskIds.get(expectedKey); String newRemoteListId = list.getId(); container.gtaskMetadata.setValue(GtasksMetadata.ID, newRemoteTaskId); container.gtaskMetadata.setValue(GtasksMetadata.LIST_ID, newRemoteListId); gtasksMetadataService.saveTaskAndMetadata(container); break; } } if (!foundMatch) { // For non-matches, make the task look newly created container.gtaskMetadata = GtasksMetadata.createEmptyMetadata(container.task.getId()); container.gtaskMetadata.setValue(GtasksMetadata.ID, ""); // $NON-NLS-1$ if (originalListId != null) { // set the list-id based on the original listname, saved above during for-loop container.gtaskMetadata.setValue(GtasksMetadata.LIST_ID, originalListId); } else { // remote list or local list was renamed, so put this unmatched task in the default // list container.gtaskMetadata.setValue(GtasksMetadata.LIST_ID, defaultListId); } gtasksMetadataService.saveTaskAndMetadata(container); break; } } } // migrate the list-id's afterwards, so that we can put the non-matched tasks in their // original lists // if the listnames didnt change before migration (defaultlist otherwise) listService.migrateListIds(allLists); } finally { allTasksWithGtaskData.close(); } Preferences.setBoolean( GtasksPreferenceService.PREF_MIGRATION_HAS_OCCURRED, true); // Record successful migration } }
@SuppressWarnings("nls") public RemoteViews buildUpdate(Context context, int widgetId) { DependencyInjectionService.getInstance().inject(this); RemoteViews views = null; views = new RemoteViews(context.getPackageName(), R.layout.widget_initialized); int[] textIDs = TEXT_IDS; int[] separatorIDs = SEPARATOR_IDS; int numberOfTasks = 5; for (int i = 0; i < textIDs.length; i++) views.setTextViewText(textIDs[i], ""); TodorooCursor<Task> cursor = null; Filter filter = null; try { filter = getFilter(widgetId); views.setTextViewText(R.id.widget_title, filter.title); SharedPreferences publicPrefs = AstridPreferences.getPublicPrefs(this); int flags = publicPrefs.getInt(SortHelper.PREF_SORT_FLAGS, 0); int sort = publicPrefs.getInt(SortHelper.PREF_SORT_SORT, 0); String query = SortHelper.adjustQueryForFlagsAndSort(filter.sqlQuery, flags, sort) .replaceAll("LIMIT \\d+", "") + " LIMIT " + numberOfTasks; database.openForReading(); cursor = taskService.fetchFiltered( query, null, Task.ID, Task.TITLE, Task.DUE_DATE, Task.COMPLETION_DATE); Task task = new Task(); for (int i = 0; i < cursor.getCount() && i < numberOfTasks; i++) { cursor.moveToPosition(i); task.readFromCursor(cursor); String textContent = ""; int textColor = Color.WHITE; textContent = task.getValue(Task.TITLE); if (task.isCompleted()) textColor = context.getResources().getColor(R.color.task_list_done); else if (task.hasDueDate() && task.getValue(Task.DUE_DATE) < DateUtilities.now()) textColor = context.getResources().getColor(R.color.task_list_overdue); if (i > 0) views.setViewVisibility(separatorIDs[i - 1], View.VISIBLE); views.setTextViewText(textIDs[i], textContent); views.setTextColor(textIDs[i], textColor); } for (int i = cursor.getCount() - 1; i < separatorIDs.length; i++) { if (i >= 0) views.setViewVisibility(separatorIDs[i], View.INVISIBLE); } } catch (Exception e) { // can happen if database is not ready Log.e("WIDGET-UPDATE", "Error updating widget", e); } finally { if (cursor != null) cursor.close(); } updateForScreenSize(views); Intent listIntent = new Intent(context, TaskListActivity.class); String customIntent = Preferences.getStringValue(WidgetConfigActivity.PREF_CUSTOM_INTENT + widgetId); if (customIntent != null) { listIntent.setComponent(ComponentName.unflattenFromString(customIntent)); String serializedExtras = Preferences.getStringValue(WidgetConfigActivity.PREF_CUSTOM_EXTRAS + widgetId); Bundle extras = AndroidUtilities.bundleFromSerializedString(serializedExtras); listIntent.putExtras(extras); } listIntent.putExtra(TaskListActivity.TOKEN_SOURCE, Constants.SOURCE_WIDGET); listIntent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_MULTIPLE_TASK); if (filter != null) { listIntent.putExtra(TaskListActivity.TOKEN_FILTER, filter); listIntent.setAction("L" + widgetId + filter.sqlQuery); } PendingIntent pendingIntent = PendingIntent.getActivity( context, widgetId, listIntent, PendingIntent.FLAG_CANCEL_CURRENT); views.setOnClickPendingIntent(R.id.taskbody, pendingIntent); Intent editIntent = new Intent(context, TaskEditActivity.class); editIntent.setFlags( Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED); if (filter != null && filter.valuesForNewTasks != null) { String values = AndroidUtilities.contentValuesToSerializedString(filter.valuesForNewTasks); editIntent.putExtra(TaskEditActivity.TOKEN_VALUES, values); editIntent.setType(values); } pendingIntent = PendingIntent.getActivity(context, 0, editIntent, 0); views.setOnClickPendingIntent(R.id.widget_button, pendingIntent); return views; }
private static void setNormalPreferenceDefaults() { Context context = ContextManager.getContext(); SharedPreferences prefs = Preferences.getPrefs(context); Editor editor = prefs.edit(); Resources r = context.getResources(); Preferences.setIfUnset(prefs, editor, r, R.string.p_default_urgency_key, 0); Preferences.setIfUnset(prefs, editor, r, R.string.p_default_importance_key, 2); Preferences.setIfUnset(prefs, editor, r, R.string.p_default_hideUntil_key, 0); Preferences.setIfUnset( prefs, editor, r, R.string.p_default_reminders_key, Task.NOTIFY_AT_DEADLINE | Task.NOTIFY_AFTER_DEADLINE); Preferences.setIfUnset(prefs, editor, r, R.string.p_rmd_default_random_hours, 0); Preferences.setIfUnset(prefs, editor, r, R.string.p_fontSize, 16); Preferences.setIfUnset(prefs, editor, r, R.string.p_showNotes, false); Preferences.setIfUnset(prefs, editor, r, R.string.p_use_contact_picker, true); Preferences.setIfUnset(prefs, editor, r, R.string.p_field_missed_calls, true); Preferences.setIfUnset(prefs, editor, r, R.string.p_third_party_addons, false); Preferences.setIfUnset(prefs, editor, r, R.string.p_end_at_deadline, true); Preferences.setIfUnset(prefs, editor, r, R.string.p_rmd_persistent, true); Preferences.setIfUnset(prefs, editor, r, R.string.p_ideas_tab_enabled, true); Preferences.setIfUnset(prefs, editor, r, R.string.p_show_featured_lists, true); Preferences.setIfUnset(prefs, editor, r, R.string.p_taskRowStyle, false); Preferences.setIfUnset(prefs, editor, r, R.string.p_calendar_reminders, true); String dragDropTestInitialized = "android_drag_drop_initialized"; // $NON-NLS-1$ if (!Preferences.getBoolean(dragDropTestInitialized, false)) { SharedPreferences publicPrefs = getPublicPrefs(context); if (publicPrefs != null) { Editor edit = publicPrefs.edit(); if (edit != null) { edit.putInt(SortHelper.PREF_SORT_FLAGS, SortHelper.FLAG_DRAG_DROP); edit.putInt(SortHelper.PREF_SORT_SORT, SortHelper.SORT_AUTO); edit.commit(); Preferences.setInt(P_SUBTASKS_HELP, 1); } } Preferences.setBoolean(dragDropTestInitialized, true); } if ("white-blue" .equals( Preferences.getStringValue( R.string.p_theme))) { // $NON-NLS-1$ migrate from when white-blue wasn't the default Preferences.setString(R.string.p_theme, ThemeService.THEME_WHITE); } if (Constants.MARKET_STRATEGY.defaultPhoneLayout()) { Preferences.setIfUnset(prefs, editor, r, R.string.p_force_phone_layout, true); } setShowFriendsView(); setShowFeaturedLists(); editor.commit(); }
/** The name (e.g. 4.0.1) of the currently installed version of astrid */ public static String getCurrentVersionName() { String versionName = Preferences.getStringValue(P_CURRENT_VERSION_NAME); if (versionName == null) versionName = "0"; // $NON-NLS-1$ return versionName; }
/** Synchronize with server when data changes */ public void pushTaskOnSave(Task task, ContentValues values, GtasksInvoker invoker, boolean sleep) throws IOException { if (sleep) AndroidUtilities.sleepDeep(1000L); // Wait for metadata to be saved Metadata gtasksMetadata = gtasksMetadataService.getTaskMetadata(task.getId()); com.google.api.services.tasks.model.Task remoteModel = null; boolean newlyCreated = false; String remoteId = null; String listId = Preferences.getStringValue(GtasksPreferenceService.PREF_DEFAULT_LIST); if (listId == null) { com.google.api.services.tasks.model.TaskList defaultList = invoker.getGtaskList(DEFAULT_LIST); if (defaultList != null) { listId = defaultList.getId(); Preferences.setString(GtasksPreferenceService.PREF_DEFAULT_LIST, listId); } else { listId = DEFAULT_LIST; } } if (gtasksMetadata == null || !gtasksMetadata.containsNonNullValue(GtasksMetadata.ID) || TextUtils.isEmpty(gtasksMetadata.getValue(GtasksMetadata.ID))) { // Create case if (gtasksMetadata == null) { gtasksMetadata = GtasksMetadata.createEmptyMetadata(task.getId()); } if (gtasksMetadata.containsNonNullValue(GtasksMetadata.LIST_ID)) { listId = gtasksMetadata.getValue(GtasksMetadata.LIST_ID); } remoteModel = new com.google.api.services.tasks.model.Task(); newlyCreated = true; } else { // update case remoteId = gtasksMetadata.getValue(GtasksMetadata.ID); listId = gtasksMetadata.getValue(GtasksMetadata.LIST_ID); remoteModel = new com.google.api.services.tasks.model.Task(); remoteModel.setId(remoteId); } // If task was newly created but without a title, don't sync--we're in the middle of // creating a task which may end up being cancelled if (newlyCreated && (!values.containsKey(Task.TITLE.name) || TextUtils.isEmpty(task.getValue(Task.TITLE)))) { return; } // Update the remote model's changed properties if (values.containsKey(Task.DELETION_DATE.name) && task.isDeleted()) { remoteModel.setDeleted(true); } if (values.containsKey(Task.TITLE.name)) { remoteModel.setTitle(task.getValue(Task.TITLE)); } if (values.containsKey(Task.NOTES.name)) { remoteModel.setNotes(task.getValue(Task.NOTES)); } if (values.containsKey(Task.DUE_DATE.name) && task.hasDueDate()) { remoteModel.setDue(GtasksApiUtilities.unixTimeToGtasksDueDate(task.getValue(Task.DUE_DATE))); } if (values.containsKey(Task.COMPLETION_DATE.name)) { if (task.isCompleted()) { remoteModel.setCompleted( GtasksApiUtilities.unixTimeToGtasksCompletionTime(task.getValue(Task.COMPLETION_DATE))); remoteModel.setStatus("completed"); // $NON-NLS-1$ } else { remoteModel.setCompleted(null); remoteModel.setStatus("needsAction"); // $NON-NLS-1$ } } if (!newlyCreated) { invoker.updateGtask(listId, remoteModel); } else { String parent = gtasksMetadataService.getRemoteParentId(gtasksMetadata); String priorSibling = gtasksMetadataService.getRemoteSiblingId(listId, gtasksMetadata); CreateRequest create = new CreateRequest(invoker, listId, remoteModel, parent, priorSibling); com.google.api.services.tasks.model.Task created = create.executePush(); if (created != null) { // Update the metadata for the newly created task gtasksMetadata.setValue(GtasksMetadata.ID, created.getId()); gtasksMetadata.setValue(GtasksMetadata.LIST_ID, listId); } else return; } task.setValue(Task.MODIFICATION_DATE, DateUtilities.now()); gtasksMetadata.setValue(GtasksMetadata.LAST_SYNC, DateUtilities.now() + 1000L); metadataService.save(gtasksMetadata); task.putTransitory(SyncFlags.GTASKS_SUPPRESS_SYNC, true); taskDao.saveExistingWithSqlConstraintCheck(task); }
private static void readPreferenceToUser(User u, StringProperty prop, String prefKey) { String val = Preferences.getStringValue(prefKey); if (val == null) val = ""; // $NON-NLS-1$ u.setValue(prop, val); }
/** * Shows an Astrid notification. Pulls in ring tone and quiet hour settings from preferences. You * can make it say anything you like. * * @param ringTimes number of times to ring (-1 = nonstop) */ public static void showNotification( int notificationId, Intent intent, int type, String title, String text, int ringTimes) { Context context = ContextManager.getContext(); if (notificationManager == null) notificationManager = new AndroidNotificationManager(context); // quiet hours? unless alarm clock boolean quietHours = false; int quietHoursStart = Preferences.getIntegerFromString(R.string.p_rmd_quietStart, -1); int quietHoursEnd = Preferences.getIntegerFromString(R.string.p_rmd_quietEnd, -1); if (quietHoursStart != -1 && quietHoursEnd != -1 && ringTimes >= 0) { int hour = new Date().getHours(); if (quietHoursStart <= quietHoursEnd) { if (hour >= quietHoursStart && hour < quietHoursEnd) quietHours = true; } else { // wrap across 24/hour boundary if (hour >= quietHoursStart || hour < quietHoursEnd) quietHours = true; } } PendingIntent pendingIntent = PendingIntent.getActivity( context, notificationId, intent, PendingIntent.FLAG_UPDATE_CURRENT); // set up properties (name and icon) for the notification int icon; switch (Preferences.getIntegerFromString(R.string.p_rmd_icon, ICON_SET_ASTRID)) { case ICON_SET_PINK: icon = R.drawable.notif_pink_alarm; break; case ICON_SET_BORING: icon = R.drawable.notif_boring_alarm; break; default: icon = R.drawable.notif_astrid; } // create notification object Notification notification = new Notification(icon, text, System.currentTimeMillis()); notification.setLatestEventInfo(context, title, text, pendingIntent); notification.flags |= Notification.FLAG_AUTO_CANCEL; if (Preferences.getBoolean(R.string.p_rmd_persistent, true)) { notification.flags |= Notification.FLAG_NO_CLEAR | Notification.FLAG_SHOW_LIGHTS; notification.ledOffMS = 5000; notification.ledOnMS = 700; notification.ledARGB = Color.YELLOW; } else notification.defaults = Notification.DEFAULT_LIGHTS; AudioManager audioManager = (AudioManager) context.getSystemService(Context.AUDIO_SERVICE); // detect call state TelephonyManager tm = (TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE); int callState = tm.getCallState(); boolean voiceReminder = Preferences.getBoolean(R.string.p_voiceRemindersEnabled, false); // if multi-ring is activated, set up the flags for insistent // notification, and increase the volume to full volume, so the user // will actually pay attention to the alarm if (ringTimes != 1 && (type != ReminderService.TYPE_RANDOM)) { notification.audioStreamType = AudioManager.STREAM_ALARM; audioManager.setStreamVolume( AudioManager.STREAM_ALARM, audioManager.getStreamMaxVolume(AudioManager.STREAM_ALARM), 0); // insistent rings until notification is disabled if (ringTimes < 0) { notification.flags |= Notification.FLAG_INSISTENT; voiceReminder = false; } } else { notification.audioStreamType = AudioManager.STREAM_NOTIFICATION; } // quiet hours = no sound if (quietHours || callState != TelephonyManager.CALL_STATE_IDLE) { notification.sound = null; voiceReminder = false; } else { String notificationPreference = Preferences.getStringValue(R.string.p_rmd_ringtone); if (audioManager.getStreamVolume(AudioManager.STREAM_RING) == 0) { notification.sound = null; voiceReminder = false; } else if (notificationPreference != null) { if (notificationPreference.length() > 0) { Uri notificationSound = Uri.parse(notificationPreference); notification.sound = notificationSound; } else { notification.sound = null; } } else { notification.defaults |= Notification.DEFAULT_SOUND; } } // quiet hours && ! due date or snooze = no vibrate if (quietHours && !(type == ReminderService.TYPE_DUE || type == ReminderService.TYPE_SNOOZE)) { notification.vibrate = null; } else if (callState != TelephonyManager.CALL_STATE_IDLE) { notification.vibrate = null; } else { if (Preferences.getBoolean(R.string.p_rmd_vibrate, true) && audioManager.shouldVibrate(AudioManager.VIBRATE_TYPE_NOTIFICATION)) { notification.vibrate = new long[] {0, 1000, 500, 1000, 500, 1000}; } else { notification.vibrate = null; } } if (Constants.DEBUG) Log.w("Astrid", "Logging notification: " + text); // $NON-NLS-1$ //$NON-NLS-2$ for (int i = 0; i < Math.max(ringTimes, 1); i++) { notificationManager.notify(notificationId, notification); AndroidUtilities.sleepDeep(500); } if (voiceReminder) { AndroidUtilities.sleepDeep(2000); for (int i = 0; i < 50; i++) { AndroidUtilities.sleepDeep(500); if (audioManager.getMode() != AudioManager.MODE_RINGTONE) break; } try { VoiceOutputService.getVoiceOutputInstance().queueSpeak(text); } catch (VerifyError e) { // unavailable } } }