diff --git a/DataUtils.java b/DataUtils.java new file mode 100644 index 0000000..835ff7c --- /dev/null +++ b/DataUtils.java @@ -0,0 +1,2631 @@ +/* + * 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; + } +}