/* * Copyright (c) 2010-2011, The MiCode Open Source Community (www.micode.net) * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package net.micode.notes.tool; import android.content.ContentProviderOperation; import android.content.ContentProviderResult; import android.content.ContentResolver; import android.content.ContentUris; import android.content.ContentValues; import android.content.OperationApplicationException; import android.database.Cursor; import android.os.RemoteException; import android.util.Log; import net.micode.notes.data.Notes; import net.micode.notes.data.Notes.CallNote; import net.micode.notes.data.Notes.NoteColumns; import net.micode.notes.ui.NotesListAdapter.AppWidgetAttribute; import java.util.ArrayList; import java.util.HashSet; public class DataUtils {/** * 此类提供了一系列工具方法，用于查询和操作数据库中的笔记信息 */ public class NoteDatabaseUtils { /** * 检查在笔记数据库中是否存在指定类型的笔记 * * @param resolver 用于访问内容提供者的ContentResolver * @param noteId 要查询的笔记的ID * @param type 笔记的类型 * @return 如果存在且不属于回收站，则返回true；否则返回false */ public static boolean visibleInNoteDatabase(ContentResolver resolver, long noteId, int type) { // 查询指定ID和类型的笔记，排除回收站中的笔记 Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId), null, NoteColumns.TYPE + "=? AND " + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER, new String [] {String.valueOf(type)}, null); boolean exist = false; if (cursor != null) { if (cursor.getCount() > 0) { exist = true; } cursor.close(); } return exist; } /** * 检查在笔记数据库中是否存在指定ID的笔记，不论其类型 * * @param resolver 用于访问内容提供者的ContentResolver * @param noteId 要查询的笔记的ID * @return 如果存在，则返回true；否则返回false */ public static boolean existInNoteDatabase(ContentResolver resolver, long noteId) { // 查询指定ID的笔记，不做其他条件限制 Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId), null, null, null, null); boolean exist = false; if (cursor != null) { if (cursor.getCount() > 0) { exist = true; } cursor.close(); } return exist; } /** * 检查在数据数据库中是否存在指定ID的数据项 * * @param resolver 用于访问内容提供者的ContentResolver * @param dataId 要查询的数据项的ID * @return 如果存在，则返回true；否则返回false */ public static boolean existInDataDatabase(ContentResolver resolver, long dataId) { // 查询指定ID的数据项，不做其他条件限制 Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_DATA_URI, dataId), null, null, null, null); boolean exist = false; if (cursor != null) { if (cursor.getCount() > 0) { exist = true; } cursor.close(); } return exist; } /** * 检查在笔记数据库中是否存在指定名称的文件夹，且该文件夹不在回收站中 * * @param resolver 用于访问内容提供者的ContentResolver * @param name 要查询的文件夹名称 * @return 如果存在，则返回true；否则返回false */ public static boolean checkVisibleFolderName(ContentResolver resolver, String name) { // 查询指定名称的文件夹，要求其类型为文件夹且不在回收站中 Cursor cursor = resolver.query(Notes.CONTENT_NOTE_URI, null, NoteColumns.TYPE + "=" + Notes.TYPE_FOLDER + " AND " + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER + " AND " + NoteColumns.SNIPPET + "=?", new String[] { name }, null); boolean exist = false; if(cursor != null) { if(cursor.getCount() > 0) { exist = true; } cursor.close(); } return exist; } /** * 获取指定文件夹下的所有笔记小部件信息 * * @param resolver 用于访问内容提供者的ContentResolver * @param folderId 文件夹的ID * @return 包含所有笔记小部件属性的HashSet，如果无小部件则返回null */ public static HashSet getFolderNoteWidget(ContentResolver resolver, long folderId) { // 查询指定文件夹下的所有笔记，提取其小部件ID和类型 Cursor c = resolver.query(Notes.CONTENT_NOTE_URI, new String[] { NoteColumns.WIDGET_ID, NoteColumns.WIDGET_TYPE }, NoteColumns.PARENT_ID + "=?", new String[] { String.valueOf(folderId) }, null); HashSet set = null; if (c != null) { if (c.moveToFirst()) { set = new HashSet(); do { try { AppWidgetAttribute widget = new AppWidgetAttribute(); widget.widgetId = c.getInt(0); widget.widgetType = c.getInt(1); set.add(widget); } catch (IndexOutOfBoundsException e) { Log.e(TAG, e.toString()); } } while (c.moveToNext()); } c.close(); } return set; } /** * 根据笔记ID获取通话记录中的电话号码 * * @param resolver 用于访问内容提供者的ContentResolver * @param noteId 要查询的笔记的ID * @return 电话号码字符串，如果查询失败或无结果则返回空字符串 */ public static String getCallNumberByNoteId(ContentResolver resolver, long noteId) { // 查询指定笔记ID的通话记录，提取电话号码 Cursor cursor = resolver.query(Notes.CONTENT_DATA_URI, new String [] { CallNote.PHONE_NUMBER }, CallNote.NOTE_ID + "=? AND " + CallNote.MIME_TYPE + "=?", new String [] { String.valueOf(noteId), CallNote.CONTENT_ITEM_TYPE }, null); if (cursor != null && cursor.moveToFirst()) { try { return cursor.getString(0); } catch (IndexOutOfBoundsException e) { Log.e(TAG, "Get call number fails " + e.toString()); } finally { cursor.close(); } } return ""; } /** * 根据电话号码和通话日期获取对应的笔记ID * * @param resolver 用于访问内容提供者的ContentResolver * @param phoneNumber 电话号码字符串 * @param callDate 通话日期的毫秒时间戳 * @return 笔记的ID，如果查询失败或无结果则返回0 */ public static long getNoteIdByPhoneNumberAndCallDate(ContentResolver resolver, String phoneNumber, long callDate) { // 查询符合条件的通话记录，提取对应的笔记ID Cursor cursor = resolver.query(Notes.CONTENT_DATA_URI, new String [] { CallNote.NOTE_ID }, CallNote.CALL_DATE + "=? AND " + CallNote.MIME_TYPE + "=? AND PHONE_NUMBERS_EQUAL(" + CallNote.PHONE_NUMBER + ",?)", new String [] { String.valueOf(callDate), CallNote.CONTENT_ITEM_TYPE, phoneNumber }, null); if (cursor != null) { if (cursor.moveToFirst()) { try { return cursor.getLong(0); } catch (IndexOutOfBoundsException e) { Log.e(TAG, "Get call note id fails " + e.toString()); } } cursor.close(); } return 0; } /** * 根据笔记ID获取其摘要信息 * * @param resolver 用于访问内容提供者的ContentResolver * @param noteId 要查询的笔记的ID * @return 笔记的摘要字符串，如果查询失败或无结果则抛出IllegalArgumentException异常 */ public static String getSnippetById(ContentResolver resolver, long noteId) { // 查询指定ID的笔记，提取其摘要信息 Cursor cursor = resolver.query(Notes.CONTENT_NOTE_URI, new String [] { NoteColumns.SNIPPET }, NoteColumns.ID + "=?", new String [] { String.valueOf(noteId)}, null); if (cursor != null) { String snippet = ""; if (cursor.moveToFirst()) { snippet = cursor.getString(0); } cursor.close(); return snippet; } throw new IllegalArgumentException("Note is not found with id: " + noteId); } /** * 格式化笔记摘要，移除多余的换行符 * * @param snippet 原始的笔记摘要字符串 * @return 格式化后的笔记摘要字符串 */ public static String getFormattedSnippet(String snippet) { if (snippet != null) { snippet = snippet.trim(); int index = snippet.indexOf('\n'); if (index != -1) { snippet = snippet.substring(0, index); } } return snippet; } } /** * 此类提供了一系列工具方法，用于查询和操作数据库中的笔记信息 */ public class NoteDatabaseUtils { /** * 检查在笔记数据库中是否存在指定类型的笔记 * * @param resolver 用于访问内容提供者的ContentResolver * @param noteId 要查询的笔记的ID * @param type 笔记的类型 * @return 如果存在且不属于回收站，则返回true；否则返回false */ public static boolean visibleInNoteDatabase(ContentResolver resolver, long noteId, int type) { // 查询指定ID和类型的笔记，排除回收站中的笔记 Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId), null, NoteColumns.TYPE + "=? AND " + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER, new String [] {String.valueOf(type)}, null); boolean exist = false; if (cursor != null) { if (cursor.getCount() > 0) { exist = true; } cursor.close(); } return exist; } /** * 检查在笔记数据库中是否存在指定ID的笔记，不论其类型 * * @param resolver 用于访问内容提供者的ContentResolver * @param noteId 要查询的笔记的ID * @return 如果存在，则返回true；否则返回false */ public static boolean existInNoteDatabase(ContentResolver resolver, long noteId) { // 查询指定ID的笔记，不做其他条件限制 Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId), null, null, null, null); boolean exist = false; if (cursor != null) { if (cursor.getCount() > 0) { exist = true; } cursor.close(); } return exist; } /** * 检查在数据数据库中是否存在指定ID的数据项 * * @param resolver 用于访问内容提供者的ContentResolver * @param dataId 要查询的数据项的ID * @return 如果存在，则返回true；否则返回false */ public static boolean existInDataDatabase(ContentResolver resolver, long dataId) { // 查询指定ID的数据项，不做其他条件限制 Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_DATA_URI, dataId), null, null, null, null); boolean exist = false; if (cursor != null) { if (cursor.getCount() > 0) { exist = true; } cursor.close(); } return exist; } /** * 检查在笔记数据库中是否存在指定名称的文件夹，且该文件夹不在回收站中 * * @param resolver 用于访问内容提供者的ContentResolver * @param name 要查询的文件夹名称 * @return 如果存在，则返回true；否则返回false */ public static boolean checkVisibleFolderName(ContentResolver resolver, String name) { // 查询指定名称的文件夹，要求其类型为文件夹且不在回收站中 Cursor cursor = resolver.query(Notes.CONTENT_NOTE_URI, null, NoteColumns.TYPE + "=" + Notes.TYPE_FOLDER + " AND " + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER + " AND " + NoteColumns.SNIPPET + "=?", new String[] { name }, null); boolean exist = false; if(cursor != null) { if(cursor.getCount() > 0) { exist = true; } cursor.close(); } return exist; } /** * 获取指定文件夹下的所有笔记小部件信息 * * @param resolver 用于访问内容提供者的ContentResolver * @param folderId 文件夹的ID * @return 包含所有笔记小部件属性的HashSet，如果无小部件则返回null */ public static HashSet getFolderNoteWidget(ContentResolver resolver, long folderId) { // 查询指定文件夹下的所有笔记，提取其小部件ID和类型 Cursor c = resolver.query(Notes.CONTENT_NOTE_URI, new String[] { NoteColumns.WIDGET_ID, NoteColumns.WIDGET_TYPE }, NoteColumns.PARENT_ID + "=?", new String[] { String.valueOf(folderId) }, null); HashSet set = null; if (c != null) { if (c.moveToFirst()) { set = new HashSet(); do { try { AppWidgetAttribute widget = new AppWidgetAttribute(); widget.widgetId = c.getInt(0); widget.widgetType = c.getInt(1); set.add(widget); } catch (IndexOutOfBoundsException e) { Log.e(TAG, e.toString()); } } while (c.moveToNext()); } c.close(); } return set; } /** * 根据笔记ID获取通话记录中的电话号码 * * @param resolver 用于访问内容提供者的ContentResolver * @param noteId 要查询的笔记的ID * @return 电话号码字符串，如果查询失败或无结果则返回空字符串 */ public static String getCallNumberByNoteId(ContentResolver resolver, long noteId) { // 查询指定笔记ID的通话记录，提取电话号码 Cursor cursor = resolver.query(Notes.CONTENT_DATA_URI, new String [] { CallNote.PHONE_NUMBER }, CallNote.NOTE_ID + "=? AND " + CallNote.MIME_TYPE + "=?", new String [] { String.valueOf(noteId), CallNote.CONTENT_ITEM_TYPE }, null); if (cursor != null && cursor.moveToFirst()) { try { return cursor.getString(0); } catch (IndexOutOfBoundsException e) { Log.e(TAG, "Get call number fails " + e.toString()); } finally { cursor.close(); } } return ""; } /** * 根据电话号码和通话日期获取对应的笔记ID * * @param resolver 用于访问内容提供者的ContentResolver * @param phoneNumber 电话号码字符串 * @param callDate 通话日期的毫秒时间戳 * @return 笔记的ID，如果查询失败或无结果则返回0 */ public static long getNoteIdByPhoneNumberAndCallDate(ContentResolver resolver, String phoneNumber, long callDate) { // 查询符合条件的通话记录，提取对应的笔记ID Cursor cursor = resolver.query(Notes.CONTENT_DATA_URI, new String [] { CallNote.NOTE_ID }, CallNote.CALL_DATE + "=? AND " + CallNote.MIME_TYPE + "=? AND PHONE_NUMBERS_EQUAL(" + CallNote.PHONE_NUMBER + ",?)", new String [] { String.valueOf(callDate), CallNote.CONTENT_ITEM_TYPE, phoneNumber }, null); if (cursor != null) { if (cursor.moveToFirst()) { try { return cursor.getLong(0); } catch (IndexOutOfBoundsException e) { Log.e(TAG, "Get call note id fails " + e.toString()); } } cursor.close(); } return 0; }/** * 此类提供了一系列工具方法，用于查询和操作数据库中的笔记信息 */ public class NoteDatabaseUtils { /** * 检查在笔记数据库中是否存在指定类型的笔记 * * @param resolver 用于访问内容提供者的ContentResolver * @param noteId 要查询的笔记的ID * @param type 笔记的类型 * @return 如果存在且不属于回收站，则返回true；否则返回false */ public static boolean visibleInNoteDatabase(ContentResolver resolver, long noteId, int type) { // 查询指定ID和类型的笔记，排除回收站中的笔记 Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId), null, NoteColumns.TYPE + "=? AND " + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER, new String [] {String.valueOf(type)}, null); boolean exist = false; if (cursor != null) { if (cursor.getCount() > 0) { exist = true; } cursor.close(); } return exist; } /** * 检查在笔记数据库中是否存在指定ID的笔记，不论其类型 * * @param resolver 用于访问内容提供者的ContentResolver * @param noteId 要查询的笔记的ID * @return 如果存在，则返回true；否则返回false */ public static boolean existInNoteDatabase(ContentResolver resolver, long noteId) { // 查询指定ID的笔记，不做其他条件限制 Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId), null, null, null, null); boolean exist = false; if (cursor != null) { if (cursor.getCount() > 0) { exist = true; } cursor.close(); } return exist; } /** * 检查在数据数据库中是否存在指定ID的数据项 * * @param resolver 用于访问内容提供者的ContentResolver * @param dataId 要查询的数据项的ID * @return 如果存在，则返回true；否则返回false */ public static boolean existInDataDatabase(ContentResolver resolver, long dataId) { // 查询指定ID的数据项，不做其他条件限制 Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_DATA_URI, dataId), null, null, null, null); boolean exist = false; if (cursor != null) { if (cursor.getCount() > 0) { exist = true; } cursor.close(); } return exist; } /** * 检查在笔记数据库中是否存在指定名称的文件夹，且该文件夹不在回收站中 * * @param resolver 用于访问内容提供者的ContentResolver * @param name 要查询的文件夹名称 * @return 如果存在，则返回true；否则返回false */ public static boolean checkVisibleFolderName(ContentResolver resolver, String name) { // 查询指定名称的文件夹，要求其类型为文件夹且不在回收站中 Cursor cursor = resolver.query(Notes.CONTENT_NOTE_URI, null, NoteColumns.TYPE + "=" + Notes.TYPE_FOLDER + " AND " + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER + " AND " + NoteColumns.SNIPPET + "=?", new String[] { name }, null); boolean exist = false; if(cursor != null) { if(cursor.getCount() > 0) { exist = true; } cursor.close(); } return exist; } /** * 获取指定文件夹下的所有笔记小部件信息 * * @param resolver 用于访问内容提供者的ContentResolver * @param folderId 文件夹的ID * @return 包含所有笔记小部件属性的HashSet，如果无小部件则返回null */ public static HashSet getFolderNoteWidget(ContentResolver resolver, long folderId) { // 查询指定文件夹下的所有笔记，提取其小部件ID和类型 Cursor c = resolver.query(Notes.CONTENT_NOTE_URI, new String[] { NoteColumns.WIDGET_ID, NoteColumns.WIDGET_TYPE }, NoteColumns.PARENT_ID + "=?", new String[] { String.valueOf(folderId) }, null); HashSet set = null; if (c != null) { if (c.moveToFirst()) { set = new HashSet(); do { try { AppWidgetAttribute widget = new AppWidgetAttribute(); widget.widgetId = c.getInt(0); widget.widgetType = c.getInt(1); set.add(widget); } catch (IndexOutOfBoundsException e) { Log.e(TAG, e.toString()); } } while (c.moveToNext()); } c.close(); } return set; } /** * 根据笔记ID获取通话记录中的电话号码 * * @param resolver 用于访问内容提供者的ContentResolver * @param noteId 要查询的笔记的ID * @return 电话号码字符串，如果查询失败或无结果则返回空字符串 */ public static String getCallNumberByNoteId(ContentResolver resolver, long noteId) { // 查询指定笔记ID的通话记录，提取电话号码 Cursor cursor = resolver.query(Notes.CONTENT_DATA_URI, new String [] { CallNote.PHONE_NUMBER }, CallNote.NOTE_ID + "=? AND " + CallNote.MIME_TYPE + "=?", new String [] { String.valueOf(noteId), CallNote.CONTENT_ITEM_TYPE }, null); if (cursor != null && cursor.moveToFirst()) { try { return cursor.getString(0); } catch (IndexOutOfBoundsException e) { Log.e(TAG, "Get call number fails " + e.toString()); } finally { cursor.close(); } } return ""; } /** * 根据电话号码和通话日期获取对应的笔记ID * * @param resolver 用于访问内容提供者的ContentResolver * @param phoneNumber 电话号码字符串 * @param callDate 通话日期的毫秒时间戳 * @return 笔记的ID，如果查询失败或无结果则返回0 */ public static long getNoteIdByPhoneNumberAndCallDate(ContentResolver resolver, String phoneNumber, long callDate) { // 查询符合条件的通话记录，提取对应的笔记ID Cursor cursor = resolver.query(Notes.CONTENT_DATA_URI, new String [] { CallNote.NOTE_ID }, CallNote.CALL_DATE + "=? AND " + CallNote.MIME_TYPE + "=? AND PHONE_NUMBERS_EQUAL(" + CallNote.PHONE_NUMBER + ",?)", new String [] { String.valueOf(callDate), CallNote.CONTENT_ITEM_TYPE, phoneNumber }, null); if (cursor != null) { if (cursor.moveToFirst()) { try { return cursor.getLong(0); } catch (IndexOutOfBoundsException e) { Log.e(TAG, "Get call note id fails " + e.toString()); } } cursor.close(); } return 0; } /** * 根据笔记ID获取其摘要信息 * * @param resolver 用于访问内容提供者的ContentResolver * @param noteId 要查询的笔记的ID * @return 笔记的摘要字符串，如果查询失败或无结果则抛出IllegalArgumentException异常 */ public static String getSnippetById(ContentResolver resolver, long noteId) { // 查询指定ID的笔记，提取其摘要信息 Cursor cursor = resolver.query(Notes.CONTENT_NOTE_URI, new String [] { NoteColumns.SNIPPET }, NoteColumns.ID + "=?", new String [] { String.valueOf(noteId)}, null); if (cursor != null) { String snippet = ""; if (cursor.moveToFirst()) { snippet = cursor.getString(0); } cursor.close(); return snippet; } throw new IllegalArgumentException("Note is not found with id: " + noteId); } /** * 格式化笔记摘要，移除多余的换行符 * * @param snippet 原始的笔记摘要字符串 * @return 格式化后的笔记摘要字符串 */ public static String getFormattedSnippet(String snippet) { if (snippet != null) { snippet = snippet.trim(); int index = snippet.indexOf('\n'); if (index != -1) { snippet = snippet.substring(0, index); } } return snippet; } } /** * 根据笔记ID获取其摘要信息 * * @param resolver 用于访问内容提供者的ContentResolver * @param noteId 要查询的笔记的ID * @return 笔记的摘要字符串，如果查询失败或无结果则抛出IllegalArgumentException异常 */ public static String getSnippetById(ContentResolver resolver, long noteId) { // 查询指定ID的笔记，提取其摘要信息 Cursor cursor = resolver.query(Notes.CONTENT_NOTE_URI, new String [] { NoteColumns.SNIPPET }, NoteColumns.ID + "=?", new String [] { String.valueOf(noteId)}, null); if (cursor != null) { String snippet = ""; if (cursor.moveToFirst()) { snippet = cursor.getString(0); } cursor.close(); return snippet; } throw new IllegalArgumentException("Note is not found with id: " + noteId); } /** * 格式化笔记摘要，移除多余的换行符 * * @param snippet 原始的笔记摘要字符串 * @return 格式化后的笔记摘要字符串 */ public static String getFormattedSnippet(String snippet) { if (snippet != null) { snippet = snippet.trim(); int index = snippet.indexOf('\n'); if (index != -1) { snippet = snippet.substring(0, index); } } return snippet; } } /** * 此类提供了一系列工具方法，用于查询和操作数据库中的笔记信息 */ public class NoteDatabaseUtils { /** * 检查在笔记数据库中是否存在指定类型的笔记 * * @param resolver 用于访问内容提供者的ContentResolver * @param noteId 要查询的笔记的ID * @param type 笔记的类型 * @return 如果存在且不属于回收站，则返回true；否则返回false */ public static boolean visibleInNoteDatabase(ContentResolver resolver, long noteId, int type) { // 查询指定ID和类型的笔记，排除回收站中的笔记 Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId), null, NoteColumns.TYPE + "=? AND " + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER, new String [] {String.valueOf(type)}, null); boolean exist = false; if (cursor != null) { if (cursor.getCount() > 0) { exist = true; } cursor.close(); } return exist; } /** * 检查在笔记数据库中是否存在指定ID的笔记，不论其类型 * * @param resolver 用于访问内容提供者的ContentResolver * @param noteId 要查询的笔记的ID * @return 如果存在，则返回true；否则返回false */ public static boolean existInNoteDatabase(ContentResolver resolver, long noteId) { // 查询指定ID的笔记，不做其他条件限制 Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId), null, null, null, null); boolean exist = false; if (cursor != null) { if (cursor.getCount() > 0) { exist = true; } cursor.close(); } return exist; } /** * 检查在数据数据库中是否存在指定ID的数据项 * * @param resolver 用于访问内容提供者的ContentResolver * @param dataId 要查询的数据项的ID * @return 如果存在，则返回true；否则返回false */ public static boolean existInDataDatabase(ContentResolver resolver, long dataId) { // 查询指定ID的数据项，不做其他条件限制 Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_DATA_URI, dataId), null, null, null, null); boolean exist = false; if (cursor != null) { if (cursor.getCount() > 0) { exist = true; } cursor.close(); } return exist; } /** * 检查在笔记数据库中是否存在指定名称的文件夹，且该文件夹不在回收站中 * * @param resolver 用于访问内容提供者的ContentResolver * @param name 要查询的文件夹名称 * @return 如果存在，则返回true；否则返回false */ public static boolean checkVisibleFolderName(ContentResolver resolver, String name) { // 查询指定名称的文件夹，要求其类型为文件夹且不在回收站中 Cursor cursor = resolver.query(Notes.CONTENT_NOTE_URI, null, NoteColumns.TYPE + "=" + Notes.TYPE_FOLDER + " AND " + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER + " AND " + NoteColumns.SNIPPET + "=?", new String[] { name }, null); boolean exist = false; if(cursor != null) { if(cursor.getCount() > 0) { exist = true; } cursor.close(); } return exist; } /** * 获取指定文件夹下的所有笔记小部件信息 * * @param resolver 用于访问内容提供者的ContentResolver * @param folderId 文件夹的ID * @return 包含所有笔记小部件属性的HashSet，如果无小部件则返回null */ public static HashSet getFolderNoteWidget(ContentResolver resolver, long folderId) { // 查询指定文件夹下的所有笔记，提取其小部件ID和类型 Cursor c = resolver.query(Notes.CONTENT_NOTE_URI, new String[] { NoteColumns.WIDGET_ID, NoteColumns.WIDGET_TYPE }, NoteColumns.PARENT_ID + "=?", new String[] { String.valueOf(folderId) }, null); HashSet set = null; if (c != null) { if (c.moveToFirst()) { set = new HashSet(); do { try { AppWidgetAttribute widget = new AppWidgetAttribute(); widget.widgetId = c.getInt(0); widget.widgetType = c.getInt(1); set.add(widget); } catch (IndexOutOfBoundsException e) { Log.e(TAG, e.toString()); } } while (c.moveToNext()); } c.close(); } return set; } /** * 根据笔记ID获取通话记录中的电话号码 * * @param resolver 用于访问内容提供者的ContentResolver * @param noteId 要查询的笔记的ID * @return 电话号码字符串，如果查询失败或无结果则返回空字符串 */ public static String getCallNumberByNoteId(ContentResolver resolver, long noteId) { // 查询指定笔记ID的通话记录，提取电话号码 Cursor cursor = resolver.query(Notes.CONTENT_DATA_URI, new String [] { CallNote.PHONE_NUMBER }, CallNote.NOTE_ID + "=? AND " + CallNote.MIME_TYPE + "=?", new String [] { String.valueOf(noteId), CallNote.CONTENT_ITEM_TYPE }, null); if (cursor != null && cursor.moveToFirst()) { try { return cursor.getString(0); } catch (IndexOutOfBoundsException e) { Log.e(TAG, "Get call number fails " + e.toString()); } finally { cursor.close(); } } return ""; } /** * 根据电话号码和通话日期获取对应的笔记ID * * @param resolver 用于访问内容提供者的ContentResolver * @param phoneNumber 电话号码字符串 * @param callDate 通话日期的毫秒时间戳 * @return 笔记的ID，如果查询失败或无结果则返回0 */ public static long getNoteIdByPhoneNumberAndCallDate(ContentResolver resolver, String phoneNumber, long callDate) { // 查询符合条件的通话记录，提取对应的笔记ID Cursor cursor = resolver.query(Notes.CONTENT_DATA_URI, new String [] { CallNote.NOTE_ID }, CallNote.CALL_DATE + "=? AND " + CallNote.MIME_TYPE + "=? AND PHONE_NUMBERS_EQUAL(" + CallNote.PHONE_NUMBER + ",?)", new String [] { String.valueOf(callDate), CallNote.CONTENT_ITEM_TYPE, phoneNumber }, null); if (cursor != null) { if (cursor.moveToFirst()) { try { return cursor.getLong(0); } catch (IndexOutOfBoundsException e) { Log.e(TAG, "Get call note id fails " + e.toString()); } } cursor.close(); } return 0; } /** * 根据笔记ID获取其摘要信息 * * @param resolver 用于访问内容提供者的ContentResolver * @param noteId 要查询的笔记的ID * @return 笔记的摘要字符串，如果查询失败或无结果则抛出IllegalArgumentException异常 */ public static String getSnippetById(ContentResolver resolver, long noteId) { // 查询指定ID的笔记，提取其摘要信息 Cursor cursor = resolver.query(Notes.CONTENT_NOTE_URI, new String [] { NoteColumns.SNIPPET }, NoteColumns.ID + "=?", new String [] { String.valueOf(noteId)}, null); if (cursor != null) { String snippet = ""; if (cursor.moveToFirst()) { snippet = cursor.getString(0); } cursor.close(); return snippet; } throw new IllegalArgumentException("Note is not found with id: " + noteId); } /** * 格式化笔记摘要，移除多余的换行符 * * @param snippet 原始的笔记摘要字符串 * @return 格式化后的笔记摘要字符串 */ public static String getFormattedSnippet(String snippet) { if (snippet != null) { snippet = snippet.trim(); int index = snippet.indexOf('\n'); if (index != -1) { snippet = snippet.substring(0, index); } } return snippet; } } /** * 此类提供了一系列工具方法，用于查询和操作数据库中的笔记信息 */ public class NoteDatabaseUtils { /** * 检查在笔记数据库中是否存在指定类型的笔记 * * @param resolver 用于访问内容提供者的ContentResolver * @param noteId 要查询的笔记的ID * @param type 笔记的类型 * @return 如果存在且不属于回收站，则返回true；否则返回false */ public static boolean visibleInNoteDatabase(ContentResolver resolver, long noteId, int type) { // 查询指定ID和类型的笔记，排除回收站中的笔记 Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId), null, NoteColumns.TYPE + "=? AND " + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER, new String [] {String.valueOf(type)}, null); boolean exist = false; if (cursor != null) { if (cursor.getCount() > 0) { exist = true; } cursor.close(); } return exist; } /** * 检查在笔记数据库中是否存在指定ID的笔记，不论其类型 * * @param resolver 用于访问内容提供者的ContentResolver * @param noteId 要查询的笔记的ID * @return 如果存在，则返回true；否则返回false */ public static boolean existInNoteDatabase(ContentResolver resolver, long noteId) { // 查询指定ID的笔记，不做其他条件限制 Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId), null, null, null, null); boolean exist = false; if (cursor != null) { if (cursor.getCount() > 0) { exist = true; } cursor.close(); } return exist; } /** * 检查在数据数据库中是否存在指定ID的数据项 * * @param resolver 用于访问内容提供者的ContentResolver * @param dataId 要查询的数据项的ID * @return 如果存在，则返回true；否则返回false */ public static boolean existInDataDatabase(ContentResolver resolver, long dataId) { // 查询指定ID的数据项，不做其他条件限制 Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_DATA_URI, dataId), null, null, null, null); boolean exist = false; if (cursor != null) { if (cursor.getCount() > 0) { exist = true; } cursor.close(); } return exist; } /** * 检查在笔记数据库中是否存在指定名称的文件夹，且该文件夹不在回收站中 * * @param resolver 用于访问内容提供者的ContentResolver * @param name 要查询的文件夹名称 * @return 如果存在，则返回true；否则返回false */ public static boolean checkVisibleFolderName(ContentResolver resolver, String name) { // 查询指定名称的文件夹，要求其类型为文件夹且不在回收站中 Cursor cursor = resolver.query(Notes.CONTENT_NOTE_URI, null, NoteColumns.TYPE + "=" + Notes.TYPE_FOLDER + " AND " + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER + " AND " + NoteColumns.SNIPPET + "=?", new String[] { name }, null); boolean exist = false; if(cursor != null) { if(cursor.getCount() > 0) { exist = true; } cursor.close(); } return exist; } /** * 获取指定文件夹下的所有笔记小部件信息 * * @param resolver 用于访问内容提供者的ContentResolver * @param folderId 文件夹的ID * @return 包含所有笔记小部件属性的HashSet，如果无小部件则返回null */ public static HashSet getFolderNoteWidget(ContentResolver resolver, long folderId) { // 查询指定文件夹下的所有笔记，提取其小部件ID和类型 Cursor c = resolver.query(Notes.CONTENT_NOTE_URI, new String[] { NoteColumns.WIDGET_ID, NoteColumns.WIDGET_TYPE }, NoteColumns.PARENT_ID + "=?", new String[] { String.valueOf(folderId) }, null); HashSet set = null; if (c != null) { if (c.moveToFirst()) { set = new HashSet(); do { try { AppWidgetAttribute widget = new AppWidgetAttribute(); widget.widgetId = c.getInt(0); widget.widgetType = c.getInt(1); set.add(widget); } catch (IndexOutOfBoundsException e) { Log.e(TAG, e.toString()); } } while (c.moveToNext()); } c.close(); } return set; } /** * 根据笔记ID获取通话记录中的电话号码 * * @param resolver 用于访问内容提供者的ContentResolver * @param noteId 要查询的笔记的ID * @return 电话号码字符串，如果查询失败或无结果则返回空字符串 */ public static String getCallNumberByNoteId(ContentResolver resolver, long noteId) { // 查询指定笔记ID的通话记录，提取电话号码 Cursor cursor = resolver.query(Notes.CONTENT_DATA_URI, new String [] { CallNote.PHONE_NUMBER }, CallNote.NOTE_ID + "=? AND " + CallNote.MIME_TYPE + "=?", new String [] { String.valueOf(noteId), CallNote.CONTENT_ITEM_TYPE }, null); if (cursor != null && cursor.moveToFirst()) { try { return cursor.getString(0); } catch (IndexOutOfBoundsException e) { Log.e(TAG, "Get call number fails " + e.toString()); } finally { cursor.close(); } } return ""; } /** * 根据电话号码和通话日期获取对应的笔记ID * * @param resolver 用于访问内容提供者的ContentResolver * @param phoneNumber 电话号码字符串 * @param callDate 通话日期的毫秒时间戳 * @return 笔记的ID，如果查询失败或无结果则返回0 */ public static long getNoteIdByPhoneNumberAndCallDate(ContentResolver resolver, String phoneNumber, long callDate) { // 查询符合条件的通话记录，提取对应的笔记ID Cursor cursor = resolver.query(Notes.CONTENT_DATA_URI, new String [] { CallNote.NOTE_ID }, CallNote.CALL_DATE + "=? AND " + CallNote.MIME_TYPE + "=? AND PHONE_NUMBERS_EQUAL(" + CallNote.PHONE_NUMBER + ",?)", new String [] { String.valueOf(callDate), CallNote.CONTENT_ITEM_TYPE, phoneNumber }, null); if (cursor != null) { if (cursor.moveToFirst()) { try { return cursor.getLong(0); } catch (IndexOutOfBoundsException e) { Log.e(TAG, "Get call note id fails " + e.toString()); } } cursor.close(); } return 0; } /** * 根据笔记ID获取其摘要信息 * * @param resolver 用于访问内容提供者的ContentResolver * @param noteId 要查询的笔记的ID * @return 笔记的摘要字符串，如果查询失败或无结果则抛出IllegalArgumentException异常 */ public static String getSnippetById(ContentResolver resolver, long noteId) { // 查询指定ID的笔记，提取其摘要信息 Cursor cursor = resolver.query(Notes.CONTENT_NOTE_URI, new String [] { NoteColumns.SNIPPET }, NoteColumns.ID + "=?", new String [] { String.valueOf(noteId)}, null); if (cursor != null) { String snippet = ""; if (cursor.moveToFirst()) { snippet = cursor.getString(0); } cursor.close(); return snippet; } throw new IllegalArgumentException("Note is not found with id: " + noteId); } /** * 格式化笔记摘要，移除多余的换行符 * * @param snippet 原始的笔记摘要字符串 * @return 格式化后的笔记摘要字符串 */ public static String getFormattedSnippet(String snippet) { if (snippet != null) { snippet = snippet.trim(); int index = snippet.indexOf('\n'); if (index != -1) { snippet = snippet.substring(0, index); } } return snippet; } } /** * 此类提供了一系列工具方法，用于查询和操作数据库中的笔记信息 */ public class NoteDatabaseUtils { /** * 检查在笔记数据库中是否存在指定类型的笔记 * * @param resolver 用于访问内容提供者的ContentResolver * @param noteId 要查询的笔记的ID * @param type 笔记的类型 * @return 如果存在且不属于回收站，则返回true；否则返回false */ public static boolean visibleInNoteDatabase(ContentResolver resolver, long noteId, int type) { // 查询指定ID和类型的笔记，排除回收站中的笔记 Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId), null, NoteColumns.TYPE + "=? AND " + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER, new String [] {String.valueOf(type)}, null); boolean exist = false; if (cursor != null) { if (cursor.getCount() > 0) { exist = true; } cursor.close(); } return exist; } /** * 检查在笔记数据库中是否存在指定ID的笔记，不论其类型 * * @param resolver 用于访问内容提供者的ContentResolver * @param noteId 要查询的笔记的ID * @return 如果存在，则返回true；否则返回false */ public static boolean existInNoteDatabase(ContentResolver resolver, long noteId) { // 查询指定ID的笔记，不做其他条件限制 Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId), null, null, null, null); boolean exist = false; if (cursor != null) { if (cursor.getCount() > 0) { exist = true; } cursor.close(); } return exist; } /** * 检查在数据数据库中是否存在指定ID的数据项 * * @param resolver 用于访问内容提供者的ContentResolver * @param dataId 要查询的数据项的ID * @return 如果存在，则返回true；否则返回false */ public static boolean existInDataDatabase(ContentResolver resolver, long dataId) { // 查询指定ID的数据项，不做其他条件限制 Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_DATA_URI, dataId), null, null, null, null); boolean exist = false; if (cursor != null) { if (cursor.getCount() > 0) { exist = true; } cursor.close(); } return exist; } /** * 检查在笔记数据库中是否存在指定名称的文件夹，且该文件夹不在回收站中 * * @param resolver 用于访问内容提供者的ContentResolver * @param name 要查询的文件夹名称 * @return 如果存在，则返回true；否则返回false */ public static boolean checkVisibleFolderName(ContentResolver resolver, String name) { // 查询指定名称的文件夹，要求其类型为文件夹且不在回收站中 Cursor cursor = resolver.query(Notes.CONTENT_NOTE_URI, null, NoteColumns.TYPE + "=" + Notes.TYPE_FOLDER + " AND " + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER + " AND " + NoteColumns.SNIPPET + "=?", new String[] { name }, null); boolean exist = false; if(cursor != null) { if(cursor.getCount() > 0) { exist = true; } cursor.close(); } return exist; } /** * 获取指定文件夹下的所有笔记小部件信息 * * @param resolver 用于访问内容提供者的ContentResolver * @param folderId 文件夹的ID * @return 包含所有笔记小部件属性的HashSet，如果无小部件则返回null */ public static HashSet getFolderNoteWidget(ContentResolver resolver, long folderId) { // 查询指定文件夹下的所有笔记，提取其小部件ID和类型 Cursor c = resolver.query(Notes.CONTENT_NOTE_URI, new String[] { NoteColumns.WIDGET_ID, NoteColumns.WIDGET_TYPE }, NoteColumns.PARENT_ID + "=?", new String[] { String.valueOf(folderId) }, null); HashSet set = null; if (c != null) { if (c.moveToFirst()) { set = new HashSet(); do { try { AppWidgetAttribute widget = new AppWidgetAttribute(); widget.widgetId = c.getInt(0); widget.widgetType = c.getInt(1); set.add(widget); } catch (IndexOutOfBoundsException e) { Log.e(TAG, e.toString()); } } while (c.moveToNext()); } c.close(); } return set; } /** * 根据笔记ID获取通话记录中的电话号码 * * @param resolver 用于访问内容提供者的ContentResolver * @param noteId 要查询的笔记的ID * @return 电话号码字符串，如果查询失败或无结果则返回空字符串 */ public static String getCallNumberByNoteId(ContentResolver resolver, long noteId) { // 查询指定笔记ID的通话记录，提取电话号码 Cursor cursor = resolver.query(Notes.CONTENT_DATA_URI, new String [] { CallNote.PHONE_NUMBER }, CallNote.NOTE_ID + "=? AND " + CallNote.MIME_TYPE + "=?", new String [] { String.valueOf(noteId), CallNote.CONTENT_ITEM_TYPE }, null); if (cursor != null && cursor.moveToFirst()) { try { return cursor.getString(0); } catch (IndexOutOfBoundsException e) { Log.e(TAG, "Get call number fails " + e.toString()); } finally { cursor.close(); } } return ""; } /** * 根据电话号码和通话日期获取对应的笔记ID * * @param resolver 用于访问内容提供者的ContentResolver * @param phoneNumber 电话号码字符串 * @param callDate 通话日期的毫秒时间戳 * @return 笔记的ID，如果查询失败或无结果则返回0 */ public static long getNoteIdByPhoneNumberAndCallDate(ContentResolver resolver, String phoneNumber, long callDate) { // 查询符合条件的通话记录，提取对应的笔记ID Cursor cursor = resolver.query(Notes.CONTENT_DATA_URI, new String [] { CallNote.NOTE_ID }, CallNote.CALL_DATE + "=? AND " + CallNote.MIME_TYPE + "=? AND PHONE_NUMBERS_EQUAL(" + CallNote.PHONE_NUMBER + ",?)", new String [] { String.valueOf(callDate), CallNote.CONTENT_ITEM_TYPE, phoneNumber }, null); if (cursor != null) { if (cursor.moveToFirst()) { try { return cursor.getLong(0); } catch (IndexOutOfBoundsException e) { Log.e(TAG, "Get call note id fails " + e.toString()); } } cursor.close(); } return 0; } /** * 根据笔记ID获取其摘要信息 * * @param resolver 用于访问内容提供者的ContentResolver * @param noteId 要查询的笔记的ID * @return 笔记的摘要字符串，如果查询失败或无结果则抛出IllegalArgumentException异常 */ public static String getSnippetById(ContentResolver resolver, long noteId) { // 查询指定ID的笔记，提取其摘要信息 Cursor cursor = resolver.query(Notes.CONTENT_NOTE_URI, new String [] { NoteColumns.SNIPPET }, NoteColumns.ID + "=?", new String [] { String.valueOf(noteId)}, null); if (cursor != null) { String snippet = ""; if (cursor.moveToFirst()) { snippet = cursor.getString(0); } cursor.close(); return snippet; } throw new IllegalArgumentException("Note is not found with id: " + noteId); } /** * 格式化笔记摘要，移除多余的换行符 * * @param snippet 原始的笔记摘要字符串 * @return 格式化后的笔记摘要字符串 */ public static String getFormattedSnippet(String snippet) { if (snippet != null) { snippet = snippet.trim(); int index = snippet.indexOf('\n'); if (index != -1) { snippet = snippet.substring(0, index); } } return snippet; } } /** * 此类提供了一系列工具方法，用于查询和操作数据库中的笔记信息 */ public class NoteDatabaseUtils { /** * 检查在笔记数据库中是否存在指定类型的笔记 * * @param resolver 用于访问内容提供者的ContentResolver * @param noteId 要查询的笔记的ID * @param type 笔记的类型 * @return 如果存在且不属于回收站，则返回true；否则返回false */ public static boolean visibleInNoteDatabase(ContentResolver resolver, long noteId, int type) { // 查询指定ID和类型的笔记，排除回收站中的笔记 Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId), null, NoteColumns.TYPE + "=? AND " + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER, new String [] {String.valueOf(type)}, null); boolean exist = false; if (cursor != null) { if (cursor.getCount() > 0) { exist = true; } cursor.close(); } return exist; } /** * 检查在笔记数据库中是否存在指定ID的笔记，不论其类型 * * @param resolver 用于访问内容提供者的ContentResolver * @param noteId 要查询的笔记的ID * @return 如果存在，则返回true；否则返回false */ public static boolean existInNoteDatabase(ContentResolver resolver, long noteId) { // 查询指定ID的笔记，不做其他条件限制 Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId), null, null, null, null); boolean exist = false; if (cursor != null) { if (cursor.getCount() > 0) { exist = true; } cursor.close(); } return exist; } /** * 检查在数据数据库中是否存在指定ID的数据项 * * @param resolver 用于访问内容提供者的ContentResolver * @param dataId 要查询的数据项的ID * @return 如果存在，则返回true；否则返回false */ public static boolean existInDataDatabase(ContentResolver resolver, long dataId) { // 查询指定ID的数据项，不做其他条件限制 Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_DATA_URI, dataId), null, null, null, null); boolean exist = false; if (cursor != null) { if (cursor.getCount() > 0) { exist = true; } cursor.close(); } return exist; } /** * 检查在笔记数据库中是否存在指定名称的文件夹，且该文件夹不在回收站中 * * @param resolver 用于访问内容提供者的ContentResolver * @param name 要查询的文件夹名称 * @return 如果存在，则返回true；否则返回false */ public static boolean checkVisibleFolderName(ContentResolver resolver, String name) { // 查询指定名称的文件夹，要求其类型为文件夹且不在回收站中 Cursor cursor = resolver.query(Notes.CONTENT_NOTE_URI, null, NoteColumns.TYPE + "=" + Notes.TYPE_FOLDER + " AND " + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER + " AND " + NoteColumns.SNIPPET + "=?", new String[] { name }, null); boolean exist = false; if(cursor != null) { if(cursor.getCount() > 0) { exist = true; } cursor.close(); } return exist; } /** * 获取指定文件夹下的所有笔记小部件信息 * * @param resolver 用于访问内容提供者的ContentResolver * @param folderId 文件夹的ID * @return 包含所有笔记小部件属性的HashSet，如果无小部件则返回null */ public static HashSet getFolderNoteWidget(ContentResolver resolver, long folderId) { // 查询指定文件夹下的所有笔记，提取其小部件ID和类型 Cursor c = resolver.query(Notes.CONTENT_NOTE_URI, new String[] { NoteColumns.WIDGET_ID, NoteColumns.WIDGET_TYPE }, NoteColumns.PARENT_ID + "=?", new String[] { String.valueOf(folderId) }, null); HashSet set = null; if (c != null) { if (c.moveToFirst()) { set = new HashSet(); do { try { AppWidgetAttribute widget = new AppWidgetAttribute(); widget.widgetId = c.getInt(0); widget.widgetType = c.getInt(1); set.add(widget); } catch (IndexOutOfBoundsException e) { Log.e(TAG, e.toString()); } } while (c.moveToNext()); } c.close(); } return set; } /** * 根据笔记ID获取通话记录中的电话号码 * * @param resolver 用于访问内容提供者的ContentResolver * @param noteId 要查询的笔记的ID * @return 电话号码字符串，如果查询失败或无结果则返回空字符串 */ public static String getCallNumberByNoteId(ContentResolver resolver, long noteId) { // 查询指定笔记ID的通话记录，提取电话号码 Cursor cursor = resolver.query(Notes.CONTENT_DATA_URI, new String [] { CallNote.PHONE_NUMBER }, CallNote.NOTE_ID + "=? AND " + CallNote.MIME_TYPE + "=?", new String [] { String.valueOf(noteId), CallNote.CONTENT_ITEM_TYPE }, null); if (cursor != null && cursor.moveToFirst()) { try { return cursor.getString(0); } catch (IndexOutOfBoundsException e) { Log.e(TAG, "Get call number fails " + e.toString()); } finally { cursor.close(); } } return ""; } /** * 根据电话号码和通话日期获取对应的笔记ID * * @param resolver 用于访问内容提供者的ContentResolver * @param phoneNumber 电话号码字符串 * @param callDate 通话日期的毫秒时间戳 * @return 笔记的ID，如果查询失败或无结果则返回0 */ public static long getNoteIdByPhoneNumberAndCallDate(ContentResolver resolver, String phoneNumber, long callDate) { // 查询符合条件的通话记录，提取对应的笔记ID Cursor cursor = resolver.query(Notes.CONTENT_DATA_URI, new String [] { CallNote.NOTE_ID }, CallNote.CALL_DATE + "=? AND " + CallNote.MIME_TYPE + "=? AND PHONE_NUMBERS_EQUAL(" + CallNote.PHONE_NUMBER + ",?)", new String [] { String.valueOf(callDate), CallNote.CONTENT_ITEM_TYPE, phoneNumber }, null); if (cursor != null) { if (cursor.moveToFirst()) { try { return cursor.getLong(0); } catch (IndexOutOfBoundsException e) { Log.e(TAG, "Get call note id fails " + e.toString()); } } cursor.close(); } return 0; } /** * 根据笔记ID获取其摘要信息 * * @param resolver 用于访问内容提供者的ContentResolver * @param noteId 要查询的笔记的ID * @return 笔记的摘要字符串，如果查询失败或无结果则抛出IllegalArgumentException异常 */ public static String getSnippetById(ContentResolver resolver, long noteId) { // 查询指定ID的笔记，提取其摘要信息 Cursor cursor = resolver.query(Notes.CONTENT_NOTE_URI, new String [] { NoteColumns.SNIPPET }, NoteColumns.ID + "=?", new String [] { String.valueOf(noteId)}, null); if (cursor != null) { String snippet = ""; if (cursor.moveToFirst()) { snippet = cursor.getString(0); } cursor.close(); return snippet; } throw new IllegalArgumentException("Note is not found with id: " + noteId); } /** * 格式化笔记摘要，移除多余的换行符 * * @param snippet 原始的笔记摘要字符串 * @return 格式化后的笔记摘要字符串 */ public static String getFormattedSnippet(String snippet) { if (snippet != null) { snippet = snippet.trim(); int index = snippet.indexOf('\n'); if (index != -1) { snippet = snippet.substring(0, index); } } return snippet; } } /** * 此类提供了一系列工具方法，用于查询和操作数据库中的笔记信息 */ public class NoteDatabaseUtils { /** * 检查在笔记数据库中是否存在指定类型的笔记 * * @param resolver 用于访问内容提供者的ContentResolver * @param noteId 要查询的笔记的ID * @param type 笔记的类型 * @return 如果存在且不属于回收站，则返回true；否则返回false */ public static boolean visibleInNoteDatabase(ContentResolver resolver, long noteId, int type) { // 查询指定ID和类型的笔记，排除回收站中的笔记 Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId), null, NoteColumns.TYPE + "=? AND " + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER, new String [] {String.valueOf(type)}, null); boolean exist = false; if (cursor != null) { if (cursor.getCount() > 0) { exist = true; } cursor.close(); } return exist; } /** * 检查在笔记数据库中是否存在指定ID的笔记，不论其类型 * * @param resolver 用于访问内容提供者的ContentResolver * @param noteId 要查询的笔记的ID * @return 如果存在，则返回true；否则返回false */ public static boolean existInNoteDatabase(ContentResolver resolver, long noteId) { // 查询指定ID的笔记，不做其他条件限制 Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId), null, null, null, null); boolean exist = false; if (cursor != null) { if (cursor.getCount() > 0) { exist = true; } cursor.close(); } return exist; } /** * 检查在数据数据库中是否存在指定ID的数据项 * * @param resolver 用于访问内容提供者的ContentResolver * @param dataId 要查询的数据项的ID * @return 如果存在，则返回true；否则返回false */ public static boolean existInDataDatabase(ContentResolver resolver, long dataId) { // 查询指定ID的数据项，不做其他条件限制 Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_DATA_URI, dataId), null, null, null, null); boolean exist = false; if (cursor != null) { if (cursor.getCount() > 0) { exist = true; } cursor.close(); } return exist; } /** * 检查在笔记数据库中是否存在指定名称的文件夹，且该文件夹不在回收站中 * * @param resolver 用于访问内容提供者的ContentResolver * @param name 要查询的文件夹名称 * @return 如果存在，则返回true；否则返回false */ public static boolean checkVisibleFolderName(ContentResolver resolver, String name) { // 查询指定名称的文件夹，要求其类型为文件夹且不在回收站中 Cursor cursor = resolver.query(Notes.CONTENT_NOTE_URI, null, NoteColumns.TYPE + "=" + Notes.TYPE_FOLDER + " AND " + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER + " AND " + NoteColumns.SNIPPET + "=?", new String[] { name }, null); boolean exist = false; if(cursor != null) { if(cursor.getCount() > 0) { exist = true; } cursor.close(); } return exist; } /** * 获取指定文件夹下的所有笔记小部件信息 * * @param resolver 用于访问内容提供者的ContentResolver * @param folderId 文件夹的ID * @return 包含所有笔记小部件属性的HashSet，如果无小部件则返回null */ public static HashSet getFolderNoteWidget(ContentResolver resolver, long folderId) { // 查询指定文件夹下的所有笔记，提取其小部件ID和类型 Cursor c = resolver.query(Notes.CONTENT_NOTE_URI, new String[] { NoteColumns.WIDGET_ID, NoteColumns.WIDGET_TYPE }, NoteColumns.PARENT_ID + "=?", new String[] { String.valueOf(folderId) }, null); HashSet set = null; if (c != null) { if (c.moveToFirst()) { set = new HashSet(); do { try { AppWidgetAttribute widget = new AppWidgetAttribute(); widget.widgetId = c.getInt(0); widget.widgetType = c.getInt(1); set.add(widget); } catch (IndexOutOfBoundsException e) { Log.e(TAG, e.toString()); } } while (c.moveToNext()); } c.close(); } return set; } /** * 根据笔记ID获取通话记录中的电话号码 * * @param resolver 用于访问内容提供者的ContentResolver * @param noteId 要查询的笔记的ID * @return 电话号码字符串，如果查询失败或无结果则返回空字符串 */ public static String getCallNumberByNoteId(ContentResolver resolver, long noteId) { // 查询指定笔记ID的通话记录，提取电话号码 Cursor cursor = resolver.query(Notes.CONTENT_DATA_URI, new String [] { CallNote.PHONE_NUMBER }, CallNote.NOTE_ID + "=? AND " + CallNote.MIME_TYPE + "=?", new String [] { String.valueOf(noteId), CallNote.CONTENT_ITEM_TYPE }, null); if (cursor != null && cursor.moveToFirst()) { try { return cursor.getString(0); } catch (IndexOutOfBoundsException e) { Log.e(TAG, "Get call number fails " + e.toString()); } finally { cursor.close(); } } return ""; } /** * 根据电话号码和通话日期获取对应的笔记ID * * @param resolver 用于访问内容提供者的ContentResolver * @param phoneNumber 电话号码字符串 * @param callDate 通话日期的毫秒时间戳 * @return 笔记的ID，如果查询失败或无结果则返回0 */ public static long getNoteIdByPhoneNumberAndCallDate(ContentResolver resolver, String phoneNumber, long callDate) { // 查询符合条件的通话记录，提取对应的笔记ID Cursor cursor = resolver.query(Notes.CONTENT_DATA_URI, new String [] { CallNote.NOTE_ID }, CallNote.CALL_DATE + "=? AND " + CallNote.MIME_TYPE + "=? AND PHONE_NUMBERS_EQUAL(" + CallNote.PHONE_NUMBER + ",?)", new String [] { String.valueOf(callDate), CallNote.CONTENT_ITEM_TYPE, phoneNumber }, null); if (cursor != null) { if (cursor.moveToFirst()) { try { return cursor.getLong(0); } catch (IndexOutOfBoundsException e) { Log.e(TAG, "Get call note id fails " + e.toString()); } } cursor.close(); } return 0; } /** * 根据笔记ID获取其摘要信息 * * @param resolver 用于访问内容提供者的ContentResolver * @param noteId 要查询的笔记的ID * @return 笔记的摘要字符串，如果查询失败或无结果则抛出IllegalArgumentException异常 */ public static String getSnippetById(ContentResolver resolver, long noteId) { // 查询指定ID的笔记，提取其摘要信息 Cursor cursor = resolver.query(Notes.CONTENT_NOTE_URI, new String [] { NoteColumns.SNIPPET }, NoteColumns.ID + "=?", new String [] { String.valueOf(noteId)}, null); if (cursor != null) { String snippet = ""; if (cursor.moveToFirst()) { snippet = cursor.getString(0); } cursor.close(); return snippet; } throw new IllegalArgumentException("Note is not found with id: " + noteId); } /** * 格式化笔记摘要，移除多余的换行符 * * @param snippet 原始的笔记摘要字符串 * @return 格式化后的笔记摘要字符串 */ public static String getFormattedSnippet(String snippet) { if (snippet != null) { snippet = snippet.trim(); int index = snippet.indexOf('\n'); if (index != -1) { snippet = snippet.substring(0, index); } } return snippet; } } /** * 此类提供了一系列工具方法，用于查询和操作数据库中的笔记信息 */ public class NoteDatabaseUtils { /** * 检查在笔记数据库中是否存在指定类型的笔记 * * @param resolver 用于访问内容提供者的ContentResolver * @param noteId 要查询的笔记的ID * @param type 笔记的类型 * @return 如果存在且不属于回收站，则返回true；否则返回false */ public static boolean visibleInNoteDatabase(ContentResolver resolver, long noteId, int type) { // 查询指定ID和类型的笔记，排除回收站中的笔记 Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId), null, NoteColumns.TYPE + "=? AND " + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER, new String [] {String.valueOf(type)}, null); boolean exist = false; if (cursor != null) { if (cursor.getCount() > 0) { exist = true; } cursor.close(); } return exist; } /** * 检查在笔记数据库中是否存在指定ID的笔记，不论其类型 * * @param resolver 用于访问内容提供者的ContentResolver * @param noteId 要查询的笔记的ID * @return 如果存在，则返回true；否则返回false */ public static boolean existInNoteDatabase(ContentResolver resolver, long noteId) { // 查询指定ID的笔记，不做其他条件限制 Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId), null, null, null, null); boolean exist = false; if (cursor != null) { if (cursor.getCount() > 0) { exist = true; } cursor.close(); } return exist; } /** * 检查在数据数据库中是否存在指定ID的数据项 * * @param resolver 用于访问内容提供者的ContentResolver * @param dataId 要查询的数据项的ID * @return 如果存在，则返回true；否则返回false */ public static boolean existInDataDatabase(ContentResolver resolver, long dataId) { // 查询指定ID的数据项，不做其他条件限制 Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_DATA_URI, dataId), null, null, null, null); boolean exist = false; if (cursor != null) { if (cursor.getCount() > 0) { exist = true; } cursor.close(); } return exist; } /** * 检查在笔记数据库中是否存在指定名称的文件夹，且该文件夹不在回收站中 * * @param resolver 用于访问内容提供者的ContentResolver * @param name 要查询的文件夹名称 * @return 如果存在，则返回true；否则返回false */ public static boolean checkVisibleFolderName(ContentResolver resolver, String name) { // 查询指定名称的文件夹，要求其类型为文件夹且不在回收站中 Cursor cursor = resolver.query(Notes.CONTENT_NOTE_URI, null, NoteColumns.TYPE + "=" + Notes.TYPE_FOLDER + " AND " + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER + " AND " + NoteColumns.SNIPPET + "=?", new String[] { name }, null); boolean exist = false; if(cursor != null) { if(cursor.getCount() > 0) { exist = true; } cursor.close(); } return exist; } /** * 获取指定文件夹下的所有笔记小部件信息 * * @param resolver 用于访问内容提供者的ContentResolver * @param folderId 文件夹的ID * @return 包含所有笔记小部件属性的HashSet，如果无小部件则返回null */ public static HashSet getFolderNoteWidget(ContentResolver resolver, long folderId) { // 查询指定文件夹下的所有笔记，提取其小部件ID和类型 Cursor c = resolver.query(Notes.CONTENT_NOTE_URI, new String[] { NoteColumns.WIDGET_ID, NoteColumns.WIDGET_TYPE }, NoteColumns.PARENT_ID + "=?", new String[] { String.valueOf(folderId) }, null); HashSet set = null; if (c != null) { if (c.moveToFirst()) { set = new HashSet(); do { try { AppWidgetAttribute widget = new AppWidgetAttribute(); widget.widgetId = c.getInt(0); widget.widgetType = c.getInt(1); set.add(widget); } catch (IndexOutOfBoundsException e) { Log.e(TAG, e.toString()); } } while (c.moveToNext()); } c.close(); } return set; } /** * 根据笔记ID获取通话记录中的电话号码 * * @param resolver 用于访问内容提供者的ContentResolver * @param noteId 要查询的笔记的ID * @return 电话号码字符串，如果查询失败或无结果则返回空字符串 */ public static String getCallNumberByNoteId(ContentResolver resolver, long noteId) { // 查询指定笔记ID的通话记录，提取电话号码 Cursor cursor = resolver.query(Notes.CONTENT_DATA_URI, new String [] { CallNote.PHONE_NUMBER }, CallNote.NOTE_ID + "=? AND " + CallNote.MIME_TYPE + "=?", new String [] { String.valueOf(noteId), CallNote.CONTENT_ITEM_TYPE }, null); if (cursor != null && cursor.moveToFirst()) { try { return cursor.getString(0); } catch (IndexOutOfBoundsException e) { Log.e(TAG, "Get call number fails " + e.toString()); } finally { cursor.close(); } } return ""; } /** * 根据电话号码和通话日期获取对应的笔记ID * * @param resolver 用于访问内容提供者的ContentResolver * @param phoneNumber 电话号码字符串 * @param callDate 通话日期的毫秒时间戳 * @return 笔记的ID，如果查询失败或无结果则返回0 */ public static long getNoteIdByPhoneNumberAndCallDate(ContentResolver resolver, String phoneNumber, long callDate) { // 查询符合条件的通话记录，提取对应的笔记ID Cursor cursor = resolver.query(Notes.CONTENT_DATA_URI, new String [] { CallNote.NOTE_ID }, CallNote.CALL_DATE + "=? AND " + CallNote.MIME_TYPE + "=? AND PHONE_NUMBERS_EQUAL(" + CallNote.PHONE_NUMBER + ",?)", new String [] { String.valueOf(callDate), CallNote.CONTENT_ITEM_TYPE, phoneNumber }, null); if (cursor != null) { if (cursor.moveToFirst()) { try { return cursor.getLong(0); } catch (IndexOutOfBoundsException e) { Log.e(TAG, "Get call note id fails " + e.toString()); } } cursor.close(); } return 0; } /** * 根据笔记ID获取其摘要信息 * * @param resolver 用于访问内容提供者的ContentResolver * @param noteId 要查询的笔记的ID * @return 笔记的摘要字符串，如果查询失败或无结果则抛出IllegalArgumentException异常 */ public static String getSnippetById(ContentResolver resolver, long noteId) { // 查询指定ID的笔记，提取其摘要信息 Cursor cursor = resolver.query(Notes.CONTENT_NOTE_URI, new String [] { NoteColumns.SNIPPET }, NoteColumns.ID + "=?", new String [] { String.valueOf(noteId)}, null); if (cursor != null) { String snippet = ""; if (cursor.moveToFirst()) { snippet = cursor.getString(0); } cursor.close(); return snippet; } throw new IllegalArgumentException("Note is not found with id: " + noteId); } /** * 格式化笔记摘要，移除多余的换行符 * * @param snippet 原始的笔记摘要字符串 * @return 格式化后的笔记摘要字符串 */ public static String getFormattedSnippet(String snippet) { if (snippet != null) { snippet = snippet.trim(); int index = snippet.indexOf('\n'); if (index != -1) { snippet = snippet.substring(0, index); } } return snippet; } } /** * 此类提供了一系列工具方法，用于查询和操作数据库中的笔记信息 */ public class NoteDatabaseUtils { /** * 检查在笔记数据库中是否存在指定类型的笔记 * * @param resolver 用于访问内容提供者的ContentResolver * @param noteId 要查询的笔记的ID * @param type 笔记的类型 * @return 如果存在且不属于回收站，则返回true；否则返回false */ public static boolean visibleInNoteDatabase(ContentResolver resolver, long noteId, int type) { // 查询指定ID和类型的笔记，排除回收站中的笔记 Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId), null, NoteColumns.TYPE + "=? AND " + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER, new String [] {String.valueOf(type)}, null); boolean exist = false; if (cursor != null) { if (cursor.getCount() > 0) { exist = true; } cursor.close(); } return exist; } /** * 检查在笔记数据库中是否存在指定ID的笔记，不论其类型 * * @param resolver 用于访问内容提供者的ContentResolver * @param noteId 要查询的笔记的ID * @return 如果存在，则返回true；否则返回false */ public static boolean existInNoteDatabase(ContentResolver resolver, long noteId) { // 查询指定ID的笔记，不做其他条件限制 Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId), null, null, null, null); boolean exist = false; if (cursor != null) { if (cursor.getCount() > 0) { exist = true; } cursor.close(); } return exist; } /** * 检查在数据数据库中是否存在指定ID的数据项 * * @param resolver 用于访问内容提供者的ContentResolver * @param dataId 要查询的数据项的ID * @return 如果存在，则返回true；否则返回false */ public static boolean existInDataDatabase(ContentResolver resolver, long dataId) { // 查询指定ID的数据项，不做其他条件限制 Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_DATA_URI, dataId), null, null, null, null); boolean exist = false; if (cursor != null) { if (cursor.getCount() > 0) { exist = true; } cursor.close(); } return exist; } /** * 检查在笔记数据库中是否存在指定名称的文件夹，且该文件夹不在回收站中 * * @param resolver 用于访问内容提供者的ContentResolver * @param name 要查询的文件夹名称 * @return 如果存在，则返回true；否则返回false */ public static boolean checkVisibleFolderName(ContentResolver resolver, String name) { // 查询指定名称的文件夹，要求其类型为文件夹且不在回收站中 Cursor cursor = resolver.query(Notes.CONTENT_NOTE_URI, null, NoteColumns.TYPE + "=" + Notes.TYPE_FOLDER + " AND " + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER + " AND " + NoteColumns.SNIPPET + "=?", new String[] { name }, null); boolean exist = false; if(cursor != null) { if(cursor.getCount() > 0) { exist = true; } cursor.close(); } return exist; } /** * 获取指定文件夹下的所有笔记小部件信息 * * @param resolver 用于访问内容提供者的ContentResolver * @param folderId 文件夹的ID * @return 包含所有笔记小部件属性的HashSet，如果无小部件则返回null */ public static HashSet getFolderNoteWidget(ContentResolver resolver, long folderId) { // 查询指定文件夹下的所有笔记，提取其小部件ID和类型 Cursor c = resolver.query(Notes.CONTENT_NOTE_URI, new String[] { NoteColumns.WIDGET_ID, NoteColumns.WIDGET_TYPE }, NoteColumns.PARENT_ID + "=?", new String[] { String.valueOf(folderId) }, null); HashSet set = null; if (c != null) { if (c.moveToFirst()) { set = new HashSet(); do { try { AppWidgetAttribute widget = new AppWidgetAttribute(); widget.widgetId = c.getInt(0); widget.widgetType = c.getInt(1); set.add(widget); } catch (IndexOutOfBoundsException e) { Log.e(TAG, e.toString()); } } while (c.moveToNext()); } c.close(); } return set; } /** * 根据笔记ID获取通话记录中的电话号码 * * @param resolver 用于访问内容提供者的ContentResolver * @param noteId 要查询的笔记的ID * @return 电话号码字符串，如果查询失败或无结果则返回空字符串 */ public static String getCallNumberByNoteId(ContentResolver resolver, long noteId) { // 查询指定笔记ID的通话记录，提取电话号码 Cursor cursor = resolver.query(Notes.CONTENT_DATA_URI, new String [] { CallNote.PHONE_NUMBER }, CallNote.NOTE_ID + "=? AND " + CallNote.MIME_TYPE + "=?", new String [] { String.valueOf(noteId), CallNote.CONTENT_ITEM_TYPE }, null); if (cursor != null && cursor.moveToFirst()) { try { return cursor.getString(0); } catch (IndexOutOfBoundsException e) { Log.e(TAG, "Get call number fails " + e.toString()); } finally { cursor.close(); } } return ""; } /** * 根据电话号码和通话日期获取对应的笔记ID * * @param resolver 用于访问内容提供者的ContentResolver * @param phoneNumber 电话号码字符串 * @param callDate 通话日期的毫秒时间戳 * @return 笔记的ID，如果查询失败或无结果则返回0 */ public static long getNoteIdByPhoneNumberAndCallDate(ContentResolver resolver, String phoneNumber, long callDate) { // 查询符合条件的通话记录，提取对应的笔记ID Cursor cursor = resolver.query(Notes.CONTENT_DATA_URI, new String [] { CallNote.NOTE_ID }, CallNote.CALL_DATE + "=? AND " + CallNote.MIME_TYPE + "=? AND PHONE_NUMBERS_EQUAL(" + CallNote.PHONE_NUMBER + ",?)", new String [] { String.valueOf(callDate), CallNote.CONTENT_ITEM_TYPE, phoneNumber }, null); if (cursor != null) { if (cursor.moveToFirst()) { try { return cursor.getLong(0); } catch (IndexOutOfBoundsException e) { Log.e(TAG, "Get call note id fails " + e.toString()); } } cursor.close(); } return 0; } /** * 根据笔记ID获取其摘要信息 * * @param resolver 用于访问内容提供者的ContentResolver * @param noteId 要查询的笔记的ID * @return 笔记的摘要字符串，如果查询失败或无结果则抛出IllegalArgumentException异常 */ public static String getSnippetById(ContentResolver resolver, long noteId) { // 查询指定ID的笔记，提取其摘要信息 Cursor cursor = resolver.query(Notes.CONTENT_NOTE_URI, new String [] { NoteColumns.SNIPPET }, NoteColumns.ID + "=?", new String [] { String.valueOf(noteId)}, null); if (cursor != null) { String snippet = ""; if (cursor.moveToFirst()) { snippet = cursor.getString(0); } cursor.close(); return snippet; } throw new IllegalArgumentException("Note is not found with id: " + noteId); } /** * 格式化笔记摘要，移除多余的换行符 * * @param snippet 原始的笔记摘要字符串 * @return 格式化后的笔记摘要字符串 */ public static String getFormattedSnippet(String snippet) { if (snippet != null) { snippet = snippet.trim(); int index = snippet.indexOf('\n'); if (index != -1) { snippet = snippet.substring(0, index); } } return snippet; } } public static final String TAG = "DataUtils"; /** * 批量删除笔记 * * @param resolver ContentResolver实例，用于访问内容提供者 * @param ids 要删除的笔记ID集合 * @return 如果删除操作成功或不需要删除，则返回true；否则返回false */ public static boolean batchDeleteNotes(ContentResolver resolver, HashSet ids) { // 检查传入的ID集合是否为null if (ids == null) { Log.d(TAG, "the ids is null"); return true; } // 检查ID集合是否为空 if (ids.size() == 0) { Log.d(TAG, "no id is in the hashset"); return true; } // 创建一个ContentProviderOperation列表，用于批量删除操作 ArrayList operationList = new ArrayList(); // 遍历ID集合 for (long id : ids) { // 禁止删除根文件夹 if(id == Notes.ID_ROOT_FOLDER) { Log.e(TAG, "Don't delete system folder root"); continue; } // 为每个ID创建删除操作，并添加到操作列表中 ContentProvide public static void moveNoteToFoler(ContentResolver resolver, long id, long srcFolderId, long desFolderId) { ContentValues values = new ContentValues(); values.put(NoteColumns.PARENT_ID, desFolderId); values.put(NoteColumns.ORIGIN_PARENT_ID, srcFolderId); values.put(NoteColumns.LOCAL_MODIFIED, 1); resolver.update(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, id), values, null, null); } public static boolean batchMoveToFolder(ContentResolver resolver, HashSet ids, long folderId) { if (ids == null) { Log.d(TAG, "the ids is null"); return true; } ArrayList operationList = new ArrayList(); for (long id : ids) { ContentProviderOperation.Builder builder = ContentProviderOperation .newUpdate(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, id)); builder.withValue(NoteColumns.PARENT_ID, folderId); builder.withValue(NoteColumns.LOCAL_MODIFIED, 1); operationList.add(builder.build()); } try { ContentProviderResult[] results = resolver.applyBatch(Notes.AUTHORITY, operationList); if (results == null || results.length == 0 || results[0] == null) { Log.d(TAG, "delete notes failed, ids:" + ids.toString()); return false; } return true; } catch (RemoteException e) { Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage())); } catch (OperationApplicationException e) { Log.e(TAG, String.format("%s: %s", e.toString(), e.getMessage())); } return false; } /** * Get the all folder count except system folders {@link Notes#TYPE_SYSTEM}} */ public static int getUserFolderCount(ContentResolver resolver) { Cursor cursor =resolver.query(Notes.CONTENT_NOTE_URI, new String[] { "COUNT(*)" }, NoteColumns.TYPE + "=? AND " + NoteColumns.PARENT_ID + "<>?", new String[] { String.valueOf(Notes.TYPE_FOLDER), String.valueOf(Notes.ID_TRASH_FOLER)}, null); int count = 0; if(cursor != null) { if(cursor.moveToFirst()) { try { count = cursor.getInt(0); } catch (IndexOutOfBoundsException e) { Log.e(TAG, "get folder count failed:" + e.toString()); } finally { cursor.close(); } } } return count; } public static boolean visibleInNoteDatabase(ContentResolver resolver, long noteId, int type) { Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId), null, NoteColumns.TYPE + "=? AND " + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER, new String [] {String.valueOf(type)}, null); boolean exist = false; if (cursor != null) { if (cursor.getCount() > 0) { exist = true; } cursor.close(); } return exist; } public static boolean existInNoteDatabase(ContentResolver resolver, long noteId) { Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_NOTE_URI, noteId), null, null, null, null); boolean exist = false; if (cursor != null) { if (cursor.getCount() > 0) { exist = true; } cursor.close(); } return exist; } public static boolean existInDataDatabase(ContentResolver resolver, long dataId) { Cursor cursor = resolver.query(ContentUris.withAppendedId(Notes.CONTENT_DATA_URI, dataId), null, null, null, null); boolean exist = false; if (cursor != null) { if (cursor.getCount() > 0) { exist = true; } cursor.close(); } return exist; } public static boolean checkVisibleFolderName(ContentResolver resolver, String name) { Cursor cursor = resolver.query(Notes.CONTENT_NOTE_URI, null, NoteColumns.TYPE + "=" + Notes.TYPE_FOLDER + " AND " + NoteColumns.PARENT_ID + "<>" + Notes.ID_TRASH_FOLER + " AND " + NoteColumns.SNIPPET + "=?", new String[] { name }, null); boolean exist = false; if(cursor != null) { if(cursor.getCount() > 0) { exist = true; } cursor.close(); } return exist; } public static HashSet getFolderNoteWidget(ContentResolver resolver, long folderId) { Cursor c = resolver.query(Notes.CONTENT_NOTE_URI, new String[] { NoteColumns.WIDGET_ID, NoteColumns.WIDGET_TYPE }, NoteColumns.PARENT_ID + "=?", new String[] { String.valueOf(folderId) }, null); HashSet set = null; if (c != null) { if (c.moveToFirst()) { set = new HashSet(); do { try { AppWidgetAttribute widget = new AppWidgetAttribute(); widget.widgetId = c.getInt(0); widget.widgetType = c.getInt(1); set.add(widget); } catch (IndexOutOfBoundsException e) { Log.e(TAG, e.toString()); } } while (c.moveToNext()); } c.close(); } return set; } public static String getCallNumberByNoteId(ContentResolver resolver, long noteId) { Cursor cursor = resolver.query(Notes.CONTENT_DATA_URI, new String [] { CallNote.PHONE_NUMBER }, CallNote.NOTE_ID + "=? AND " + CallNote.MIME_TYPE + "=?", new String [] { String.valueOf(noteId), CallNote.CONTENT_ITEM_TYPE }, null); if (cursor != null && cursor.moveToFirst()) { try { return cursor.getString(0); } catch (IndexOutOfBoundsException e) { Log.e(TAG, "Get call number fails " + e.toString()); } finally { cursor.close(); } } return ""; } public static long getNoteIdByPhoneNumberAndCallDate(ContentResolver resolver, String phoneNumber, long callDate) { Cursor cursor = resolver.query(Notes.CONTENT_DATA_URI, new String [] { CallNote.NOTE_ID }, CallNote.CALL_DATE + "=? AND " + CallNote.MIME_TYPE + "=? AND PHONE_NUMBERS_EQUAL(" + CallNote.PHONE_NUMBER + ",?)", new String [] { String.valueOf(callDate), CallNote.CONTENT_ITEM_TYPE, phoneNumber }, null); if (cursor != null) { if (cursor.moveToFirst()) { try { return cursor.getLong(0); } catch (IndexOutOfBoundsException e) { Log.e(TAG, "Get call note id fails " + e.toString()); } } cursor.close(); } return 0; } public static String getSnippetById(ContentResolver resolver, long noteId) { Cursor cursor = resolver.query(Notes.CONTENT_NOTE_URI, new String [] { NoteColumns.SNIPPET }, NoteColumns.ID + "=?", new String [] { String.valueOf(noteId)}, null); if (cursor != null) { String snippet = ""; if (cursor.moveToFirst()) { snippet = cursor.getString(0); } cursor.close(); return snippet; } throw new IllegalArgumentException("Note is not found with id: " + noteId); } public static String getFormattedSnippet(String snippet) { if (snippet != null) { snippet = snippet.trim(); int index = snippet.indexOf('\n'); if (index != -1) { snippet = snippet.substring(0, index); } } return snippet; } }