כתיבת נתונים

המדריך הזה תואם לגרסה 1.1.0‎-alpha12 של Health Connect.

במדריך הזה מוסבר איך לכתוב או לעדכן נתונים ב-Health Connect.

טיפול בערכים אפסיים

יכול להיות שלחלק מסוגי הנתונים, כמו צעדים, מרחק או קלוריות, יהיה ערך של 0. לכתוב ערך אפס רק אם הוא משקף חוסר פעילות אמיתי בזמן שהמשתמש ענד את המכשיר. לא לכתוב ערכים של אפס אם המכשיר לא היה בשימוש, אם חסרים נתונים או אם הסוללה התרוקנה. במקרים כאלה, כדאי להשמיט את הרשומה כדי למנוע נתונים מטעים.

הגדרת מבנה נתונים

לפני שכותבים נתונים, צריך להגדיר את הרשומות. יש יותר מ-50 סוגי נתונים, ולכל אחד מהם יש מבנה משלו. לפרטים נוספים על סוגי הנתונים הזמינים, אפשר לעיין במאמר בנושא Jetpack.

רשומות בסיסיות

סוג הנתונים צעדים ב-Health Connect מתעד את מספר הצעדים שהמשתמש עשה בין הקריאות. ספירת הצעדים היא מדד נפוץ בפלטפורמות של בריאות, כושר ואיכות חיים.

בדוגמה הבאה אפשר לראות איך מגדירים נתונים של ספירת צעדים:

val zoneOffset = ZoneOffset.systemDefault().rules.getOffset(startTime)
val stepsRecord = StepsRecord(
    count = 120,
    startTime = startTime,
    endTime = endTime,
    startZoneOffset = zoneOffset,
    endZoneOffset = zoneOffset,
    metadata = Metadata(
        device = Device(type = Device.TYPE_WATCH),
        recordingMethod = Metadata.RECORDING_METHOD_AUTOMATICALLY_RECORDED
    )
)
healthConnectClient.insertRecords(listOf(stepsRecord))
HealthConnectManager.kt

רשומות עם יחידות מידה

כדי לספק נתונים מדויקים, אפשר לאחסן ב-Health Connect ערכים יחד עם יחידות המידה שלהם. דוגמה אחת היא סוג הנתונים Nutrition, שהוא נרחב ומקיף. הוא כולל מגוון רחב של שדות אופציונליים של רכיבי תזונה, החל מפחמימות כוללות ועד ויטמינים. כל נקודה על הגרף מייצגת את רכיבי התזונה שאולי נצרכו כחלק מארוחה או מפריט מזון.

בסוג הנתונים הזה, כל רכיבי התזונה מיוצגים ביחידות של מסה, ואילו energy מיוצג ביחידה של אנרגיה.

בדוגמה הבאה מוצג איך להגדיר נתוני תזונה למשתמש שאכל בננה:

val endTime = Instant.now()
val startTime = endTime.minus(Duration.ofMinutes(1))

val banana = NutritionRecord(
    name = "banana",
    energy = 105.0.kilocalories,
    dietaryFiber = 3.1.grams,
    potassium = 0.422.grams,
    totalCarbohydrate = 27.0.grams,
    totalFat = 0.4.grams,
    saturatedFat = 0.1.grams,
    sodium = 0.001.grams,
    sugar = 14.0.grams,
    vitaminB6 = 0.0005.grams,
    vitaminC = 0.0103.grams,
    startTime = startTime,
    endTime = endTime,
    startZoneOffset = ZoneOffset.UTC,
    endZoneOffset = ZoneOffset.UTC,
    metadata = Metadata(
        device = Device(type = Device.TYPE_PHONE)
    )
)
HealthConnectManager.kt

רשומות עם נתוני סדרה

אפליקציית Health Connect יכולה לאחסן רשימה של נתונים מסדרות. דוגמה אחת היא סוג הנתונים Heart Rate (דופק) שמתעד סדרה של דגימות של פעימות הלב שזוהו בין הקריאות.

בסוג הנתונים הזה, הפרמטר samples מיוצג על ידי רשימה של דגימות של קצב הלב. כל דגימה מכילה ערך beatsPerMinute וערך time.

בדוגמה הבאה אפשר לראות איך מגדירים נתונים של סדרת דופק:

val endTime = Instant.now()
val startTime = endTime.minus(Duration.ofMinutes(5))

val heartRateRecord = HeartRateRecord(
    startTime = startTime,
    startZoneOffset = ZoneOffset.UTC,
    endTime = endTime,
    endZoneOffset = ZoneOffset.UTC,
    // records 10 arbitrary data, to replace with actual data
    samples = List(10) { index ->
        HeartRateRecord.Sample(
            time = startTime + Duration.ofSeconds(index.toLong()),
            beatsPerMinute = 100 + index.toLong(),
        )
    },
    metadata = Metadata(
        device = Device(type = Device.TYPE_WATCH)
    ))
HealthConnectManager.kt

בקשת הרשאות מהמשתמש

אחרי שיוצרים מופע של לקוח, האפליקציה צריכה לבקש הרשאות מהמשתמש. צריך לאפשר למשתמשים להעניק או לדחות הרשאות בכל שלב. כדי לעשות זאת, יוצרים קבוצת הרשאות לסוגי הנתונים הנדרשים. קודם צריך לוודא שההרשאות בקבוצה מוצהרות במניפסט של Android.

val permissions =
    setOf(
        HealthPermission.getReadPermission(HeartRateRecord::class),
        HealthPermission.getWritePermission(HeartRateRecord::class),
        HealthPermission.getReadPermission(StepsRecord::class),
        HealthPermission.getWritePermission(StepsRecord::class)
    )
HealthConnectManager.kt

val permissions = setOf(
        HealthPermission.getReadPermission(StepsRecord::class),
        HealthPermission.getWritePermission(StepsRecord::class),
        HealthPermission.getReadPermission(HeartRateRecord::class),
        HealthPermission.getWritePermission(HeartRateRecord::class)
    )

val requestPermissionsLauncher = rememberLauncherForActivityResult(
    contract = PermissionController.createRequestPermissionResultContract()
) { grantedPermissions ->
    if (grantedPermissions.containsAll(permissions)) {
        coroutineScope.launch { snackbarHostState.showSnackbar("Permissions granted!") }
    } else {
        coroutineScope.launch { snackbarHostState.showSnackbar("Permissions denied.") }
    }
}
HealthConnectActivity.kt

כתיבת נתונים

אחד מתהליכי העבודה הנפוצים ב-Health Connect הוא כתיבת נתונים. כדי להוסיף רשומות, משתמשים ב-insertRecords.

בדוגמה הבאה אפשר לראות איך כותבים נתונים של מספר הצעדים:

val zoneOffset = ZoneOffset.systemDefault().rules.getOffset(startTime)
val stepsRecord = StepsRecord(
    count = 120,
    startTime = startTime,
    endTime = endTime,
    startZoneOffset = zoneOffset,
    endZoneOffset = zoneOffset,
    metadata = Metadata(
        device = Device(type = Device.TYPE_WATCH),
        recordingMethod = Metadata.RECORDING_METHOD_AUTOMATICALLY_RECORDED
    )
)
healthConnectClient.insertRecords(listOf(stepsRecord))
HealthConnectManager.kt

עדכון נתונים

אם אתם צריכים לשנות רשומה אחת או יותר, במיוחד כשאתם צריכים לסנכרן את מאגר הנתונים של האפליקציה עם נתונים מ-Health Connect, אתם יכולים לעדכן את הנתונים. יש שתי דרכים לעדכן נתונים קיימים, והן תלויות במזהה שמשמש לאיתור רשומות.

מטא-נתונים

כדאי לבדוק קודם את המחלקה Metadata, כי היא נחוצה כשמעדכנים נתונים. בזמן היצירה, לכל Record ב-Health Connect יש שדה metadata. המאפיינים הבאים רלוונטיים לסנכרון:

עדכון אחרי קריאה לפי טווח זמן

כדי לעדכן נתונים, קודם צריך להכין את הרשומות הנדרשות. מבצעים שינויים ברשומות לפי הצורך. לאחר מכן מתקשרים אל updateRecords כדי לבצע את השינויים.

בדוגמה הבאה מוצג איך לעדכן נתונים. לצורך זה, ערכי ההפרש מהשעון האזורי של כל רשומה מותאמים לשעון החוף הפסיפי (PST).

suspend fun updateSteps(
    healthConnectClient: HealthConnectClient,
    prevRecordStartTime: Instant,
    prevRecordEndTime: Instant
) {
    try {
        val request = healthConnectClient.readRecords(
            ReadRecordsRequest(
                recordType = StepsRecord::class, timeRangeFilter = TimeRangeFilter.between(
                    prevRecordStartTime,
                    prevRecordEndTime
                )
            )
        )

        val newStepsRecords = arrayListOf<StepsRecord>()
        for (record in request.records) {
            // Adjusted both offset values to reflect changes
            val sr = StepsRecord(
                count = record.count,
                startTime = record.startTime,
                startZoneOffset = record.startTime.atZone(ZoneId.of("PST")).offset,
                endTime = record.endTime,
                endZoneOffset = record.endTime.atZone(ZoneId.of("PST")).offset,
                metadata = record.metadata
            )
            newStepsRecords.add(sr)
        }

        healthConnectClient.updateRecords(newStepsRecords)
    } catch (e: Exception) {
        // Run error handling here
    }
}
HealthConnectManager.kt

עדכון או הוספה באמצעות מזהה רשומה של לקוח

אם אתם משתמשים בערכים האופציונליים של מזהה רשומת לקוח וגרסת רשומת לקוח, מומלץ להשתמש ב-insertRecords במקום ב-updateRecords.

הפונקציה insertRecords יכולה לבצע פעולת upsert של נתונים. אם הנתונים קיימים ב-Health Connect על סמך קבוצת מזהי הרשומות של הלקוח שצוינה, הם יוחלפו. אחרת, הנתונים נכתבים כנתונים חדשים. התרחיש הזה שימושי בכל פעם שצריך לסנכרן נתונים ממאגר הנתונים של האפליקציה עם Health Connect.

בדוגמה הבאה מוצג איך לבצע פעולת upsert על נתונים שנמשכו מחנות הנתונים של האפליקציה:

 fun pullStepsFromDatastore(startTime: Instant, endTime: Instant) : ArrayList<StepsRecord> {
    val appStepsRecords = arrayListOf<StepsRecord>()
    // Pull data from app datastore
    // ...
    // Make changes to data if necessary
    // ...
    // Store data in appStepsRecords
    // ...
    var sr = StepsRecord(
        metadata = Metadata(
            clientRecordId = "Your client record ID",
            device = Device(type = Device.TYPE_WATCH)
        ),
        startTime = startTime,
        startZoneOffset = startTime.atZone(ZoneId.of("PST")).offset,
        endTime = endTime,
        endZoneOffset = endTime.atZone(ZoneId.of("PST")).offset,
        count = 120
    )
    appStepsRecords.add(sr)
    // ...
    return appStepsRecords
}

suspend fun upsertSteps(
    healthConnectClient: HealthConnectClient,
    newStepsRecords: ArrayList<StepsRecord>
) {
    try {
        healthConnectClient.insertRecords(newStepsRecords)
    } catch (e: Exception) {
        // Run error handling here
    }
}
HealthConnectManager.kt

אחרי כן, תוכלו לקרוא לפונקציות האלה בשרשור הראשי.

upsertSteps(healthConnectClient, pullStepsFromDatastore(
    startTime = startTime,
    endTime = endTime
))
HealthConnectManager.kt

בדיקת ערך בגרסת רשומת הלקוח

אם התהליך שלכם להוספה או לעדכון של נתונים כולל את Client Record Version, ‏ Health Connect מבצע בדיקות השוואה בערכים של clientRecordVersion. אם הגרסה מהנתונים שהוסיפו גבוהה מהגרסה מהנתונים הקיימים, מתבצעת פעולת upsert. אחרת, התהליך מתעלם מהשינוי והערך נשאר ללא שינוי.

כדי לכלול ניהול גרסאות בנתונים, צריך לספק ל-Metadata.clientRecordVersion ערך Long שמבוסס על לוגיקת ניהול הגרסאות שלכם.

val endTime = Instant.now()
val startTime = endTime.minus(Duration.ofMinutes(15))

val stepsRecord = StepsRecord(
    count = 100L,
    startTime = startTime,
    startZoneOffset = ZoneOffset.UTC,
    endTime = endTime,
    endZoneOffset = ZoneOffset.UTC,
    metadata = Metadata(
        clientRecordId = "Your supplied record ID",
        clientRecordVersion = 0L, // Your supplied record version
        device = Device(type = Device.TYPE_WATCH)
    )
)
HealthConnectManager.kt

פעולות Upsert לא מגדילות אוטומטית את הערך של version בכל פעם שיש שינויים, וכך נמנעים מקרים לא צפויים של דריסת נתונים. לכן, צריך לספק לו ערך גבוה יותר באופן ידני.

הנחיות כלליות

האפליקציה צריכה לכתוב את כל הנתונים מאינטראקציה ישירה (First-Party) שנתמכים. אופציונלית, אתם יכולים לבחור שהאפליקציה שלכם תכתוב נתונים שהתקבלו ממקורות של צד שלישי. עם זאת, אם האפליקציה קראה נתונים מ-Health Connect, הנתונים האלה לא אמורים להיכתב בחזרה ל-Health Connect.

כשכותבים נתונים שיובאו ממקור אחר או נגזרו ממקור אחר, צריך לציין בצורה נכונה את המקור שלהם ואת המטא-נתונים של מכשיר המקור. לשם כך, צריך לספק את המטא-נתונים הבאים לכל רשומה שנכתבת:

• ‫recordingMethod: לגבי נתונים שנרשמו באופן אוטומטי או ידני, אנחנו מצפים ששיטת הרישום תעודכן כך שתשקף את סוג הפעילות שנרשמה:
  • ‫RECORDING_METHOD_AUTOMATICALLY_RECORDED: אם הנתונים נרשמו באופן אוטומטי, למשל אם צמיד כושר זיהה אוטומטית שהמשתמש יצא לריצה.
  • ‫RECORDING_METHOD_ACTIVELY_RECORDED: אם המשתמש התחיל פעילות חדשה, כמו רכיבה על אופניים, במכשיר הלביש שלו.
  • ‫RECORDING_METHOD_MANUAL_ENTRY: אם המשתמש הזין את הנתונים באופן ידני.
• ‫device.type: חובה לציין סוג מכשיר מתוך אחד מסוגי Device הנתונים הנתמכים.
• ‫device.manufacturer: יצרן המכשיר, לדוגמה, Fitbit.
• ‫device.model: דגם המכשיר, לדוגמה, Charge 3.

הגדרת מטא-נתונים בצורה נכונה היא קריטית לשקיפות הנתונים ועוזרת למשתמשים להבין מהו המקור של המידע הרפואי שלהם. פרטים מלאים זמינים במדריך למטא-נתונים של Health Connect.

אם הנתונים באפליקציה יובאו מאפליקציה אחרת, האחריות לכתיבת הנתונים שלה ב-Health Connect מוטלת על האפליקציה האחרת.

מומלץ גם להטמיע לוגיקה שמטפלת בחריגות של פעולות כתיבה, כמו נתונים שנמצאים מחוץ לגבולות או שגיאת מערכת פנימית. אפשר להחיל את אסטרטגיות ההשהיה והניסיון החוזר על מנגנון לתזמון משימות. אם הכתיבה ל-Health Connect לא מצליחה בסופו של דבר, צריך לוודא שהאפליקציה יכולה להמשיך מעבר לנקודת הייצוא הזו. כדי לעזור באבחון, חשוב לרשום ביומן ולדווח על שגיאות.

כשעוקבים אחרי נתונים, יש כמה הצעות שאפשר לפעול לפיהן בהתאם לאופן שבו האפליקציה כותבת נתונים.

טיפול באזור זמן

כשכותבים רשומות שמבוססות על זמן, מומלץ להימנע מהגדרת היסטים ל-zoneOffset.UTC כברירת מחדל, כי זה עלול להוביל לחותמות זמן לא מדויקות כשהמשתמשים נמצאים באזורים אחרים. במקום זאת, צריך לחשב את ההפרש על סמך המיקום בפועל של המכשיר. אפשר לאחזר את אזור הזמן של המכשיר באמצעות ZoneId.systemDefault().

val endTime = Instant.now()
val startTime = endTime.minus(Duration.ofDays(1))
val stepsRecords = mutableListOf<StepsRecord>()
var sampleTime = startTime
val minutesBetweenSamples = 15L
while (sampleTime < endTime) {
    // Get the default ZoneId then convert it to an offset
    val zoneOffset = ZoneOffset.systemDefault().rules.getOffset(sampleTime)
    stepsRecords += StepsRecord(
        startTime = sampleTime.minus(Duration.ofMinutes(minutesBetweenSamples)),
        startZoneOffset = zoneOffset,
        endTime = sampleTime,
        endZoneOffset = zoneOffset,
        count = Random.nextLong(1, 100),
        metadata = Metadata(),
    )
    sampleTime = sampleTime.plus(Duration.ofMinutes(minutesBetweenSamples))
}
healthConnectClient.insertRecords(
    stepsRecords
)
HealthConnectManager.kt

פרטים נוספים מופיעים במאמרי העזרה בנושא ZoneId.

כתיבה של נתוני התדירות ורמת הפירוט

כשכותבים נתונים ל-Health Connect, חשוב להשתמש ברזולוציה המתאימה. שימוש ברזולוציה המתאימה עוזר לצמצם את עומס האחסון, ועדיין לשמור על נתונים עקביים ומדויקים. רזולוציית הנתונים כוללת שני דברים:

• תדירות הכתיבה: באיזו תדירות האפליקציה כותבת נתונים חדשים ב-Health Connect.
  • כשיש נתונים חדשים, כדאי לכתוב אותם בתדירות גבוהה ככל האפשר, תוך התחשבות בביצועי המכשיר.
  • כדי להימנע מהשפעה שלילית על חיי הסוללה ועל היבטים אחרים של הביצועים, מרווח הזמן המקסימלי בין פעולות כתיבה צריך להיות 15 דקות.
• רמת הפירוט של הנתונים שנכתבו: באיזו תדירות נדגמו הנתונים.
  • לדוגמה, כתיבה של דגימות של נתוני הדופק כל 5 שניות.
  • לא כל סוגי הנתונים דורשים את אותו שיעור דגימה. אין הרבה יתרונות בעדכון נתוני ספירת הצעדים כל שנייה, לעומת עדכון בתדירות נמוכה יותר, כמו כל 60 שניות.
  • שיעורי דגימה גבוהים יותר יכולים לספק למשתמשים תצוגה מפורטת יותר של נתונים של אימוני כושר ובריאות. תדירויות שיעורי הדגימה צריכות לאזן בין רמת הפירוט לבין הביצועים.

הנחיות נוספות

כשכותבים נתונים, חשוב להקפיד על ההנחיות הבאות:

• בכל סנכרון, המערכת כותבת רק נתונים חדשים ונתונים מעודכנים שהשתנו מאז הסנכרון האחרון.
• צריך לחלק את הבקשות כך שכל בקשת כתיבה תכלול לכל היותר 1,000 רשומות.
• הגבלת הפעלת משימות רק כשהמכשיר לא פעיל ורמת הטעינה של הסוללה לא נמוכה.
• למשימות ברקע, צריך להשתמש ב-WorkManager כדי לתזמן משימות תקופתיות, עם תקופת זמן מקסימלית של 15 דקות.

הקוד הבא משתמש ב-WorkManager כדי לתזמן משימות תקופתיות ברקע, עם תקופת זמן מקסימלית של 15 דקות ומרווח גמיש של 5 דקות. ההגדרה הזו מוגדרת באמצעות המחלקה PeriodicWorkRequest.Builder.

val constraints = Constraints.Builder()
    .requiresBatteryNotLow()
    .requiresDeviceIdle(true)
    .build()

val writeDataWork = PeriodicWorkRequestBuilder<WriteDataToHealthConnectWorker>(
        15,
        TimeUnit.MINUTES,
        5,
        TimeUnit.MINUTES
    )
    .setConstraints(constraints)
    .build()

מעקב פעיל

הנתונים האלה כוללים אפליקציות שמבצעות מעקב מבוסס-אירועים, כמו פעילות גופנית ושינה, או קלט של משתמשים, כמו תזונה. הרשומות האלה נוצרות כשהאפליקציה פועלת בחזית, או במקרים נדירים שבהם משתמשים בה כמה פעמים ביום.

מוודאים שהאפליקציה לא מפעילה את Health Connect למשך כל משך האירוע.

הנתונים צריכים להיכתב ב-Health Connect באחת משתי דרכים:

• סנכרון נתונים עם Health Connect אחרי שהאירוע מסתיים. לדוגמה, סנכרון נתונים כשמשתמש מסיים סשן של פעילות גופנית במעקב.
• אפשר לתזמן משימה חד-פעמית באמצעות WorkManager כדי לסנכרן נתונים במועד מאוחר יותר.

שיטות מומלצות לגרנולריות ולתדירות של פעולות כתיבה

כשכותבים נתונים ל-Health Connect, צריך להשתמש ברזולוציה המתאימה. שימוש ברזולוציה המתאימה עוזר לצמצם את עומס האחסון, ועדיין לשמור על נתונים עקביים ומדויקים. רזולוציית הנתונים כוללת 2 דברים:

1. תדירות הכתיבה: כמה פעמים האפליקציה דוחפת נתונים חדשים ל-Health Connect. מומלץ לכתוב נתונים בתדירות גבוהה ככל האפשר כשנתונים חדשים זמינים, תוך התחשבות בביצועי המכשיר. כדי למנוע השפעה שלילית על חיי הסוללה ועל היבטים אחרים של הביצועים, המרווח המקסימלי בין פעולות כתיבה צריך להיות 15 דקות.

2. רמת הפירוט של הנתונים שנכתבו: באיזו תדירות נדגמו הנתונים שנשלחו. לדוגמה, כתיבה של דגימות של נתוני הדופק כל 5 שניות. לא כל סוגי הנתונים דורשים את אותו קצב דגימה. אין הרבה יתרונות בעדכון נתוני ספירת הצעדים כל שנייה, לעומת קצב עדכון פחות תדיר, כמו כל 60 שניות. עם זאת, שיעורי דגימה גבוהים יותר עשויים לספק למשתמשים תמונה מפורטת יותר של נתוני הבריאות והכושר שלהם. תדרי קצב הדגימה צריכים להיות מאוזנים בין פירוט לביצועים.

מבנה הרשומות של נתוני סדרות

בסוגי נתונים שמתבססים על סדרת דגימות, כמו HeartRateRecord, חשוב לבנות את הרשומות בצורה נכונה. במקום ליצור רשומה אחת של יום שלם שמתעדכנת כל הזמן, צריך ליצור כמה רשומות קטנות יותר, שכל אחת מהן מייצגת מרווח זמן ספציפי.

לדוגמה, כדי להוסיף נתוני דופק, צריך ליצור HeartRateRecord חדש לכל דקה. כל רשומה תכלול שעת התחלה ושעת סיום שמתייחסות לדקה הזו, ותכיל את כל דגימות הדופק שנאספו במהלך הדקה הזו.

במהלך סנכרונים רגילים עם Health Connect (לדוגמה, כל 15 דקות), האפליקציה צריכה לכתוב את כל הרשומות של דקה אחת שנוצרו מאז הסנכרון הקודם. כך אפשר לשמור על גודל סביר של הרשומות ולשפר את הביצועים של שאילתות ועיבוד נתונים.

בדוגמה הבאה אפשר לראות איך יוצרים HeartRateRecord למשך דקה אחת, שמכיל כמה דגימות:

val startTime = Instant.now().truncatedTo(ChronoUnit.MINUTES)
val endTime = startTime.plus(Duration.ofMinutes(1))

val heartRateRecord = HeartRateRecord(
    startTime = startTime,
    startZoneOffset = ZoneOffset.UTC,
    endTime = endTime,
    endZoneOffset = ZoneOffset.UTC,
    // Create a new record every minute, containing a list of samples.
    samples = listOf(
        HeartRateRecord.Sample(
            time = startTime + Duration.ofSeconds(15),
            beatsPerMinute = 80,
        ),
        HeartRateRecord.Sample(
            time = startTime + Duration.ofSeconds(30),
            beatsPerMinute = 82,
        ),
        HeartRateRecord.Sample(
            time = startTime + Duration.ofSeconds(45),
            beatsPerMinute = 85,
        )
    ),
    metadata = Metadata(
        device = Device(type = Device.TYPE_WATCH)
    ))
HealthConnectManager.kt

כתיבת נתונים שנאספים במהלך היום

לגבי נתונים שנאספים באופן שוטף, כמו מספר הצעדים, האפליקציה צריכה לכתוב ל-Health Connect בתדירות הגבוהה ביותר האפשרית כשנתונים חדשים זמינים. כדי למנוע השפעה שלילית על חיי הסוללה ועל היבטים אחרים של הביצועים, מרווח הזמן המקסימלי בין פעולות כתיבה צריך להיות 15 דקות.

הנתונים צריכים להיכתב ל-Health Connect בסוף אימון הכושר או רשומת השינה. במקרה של מעקב אחר פעילות, כמו פעילות גופנית ושינה, או קלט של משתמשים, כמו תזונה, הרשומות האלה נוצרות כשהאפליקציה פועלת בחזית, או במקרים נדירים שבהם נעשה בה שימוש כמה פעמים ביום.

מוודאים שהאפליקציה לא מפעילה את Health Connect למשך כל משך האירוע.

הנתונים צריכים להיכתב ב-Health Connect באחת משתי דרכים:

• סנכרון נתונים עם Health Connect אחרי שהאירוע מסתיים. לדוגמה, סנכרון נתונים כשמשתמש מסיים סשן של פעילות גופנית במעקב.
• אפשר לתזמן משימה חד-פעמית באמצעות WorkManager כדי לסנכרן נתונים מאוחר יותר.

סשנים של פעילות גופנית ושינה

לפחות, האפליקציה צריכה לפעול לפי ההנחיות בעמודה Expected בטבלה 2. אם אפשר, פועלים לפי ההנחיות בעמודה הכי טוב.

בטבלה הבאה מוסבר איך לכתוב נתונים במהלך תרגיל:

בטבלה 3 מוצגות הוראות לכתיבת נתונים במהלך רשומת שינה או אחריו:

אירועי ספורט רב-ענפיים

הגישה הזו משתמשת בסוגי נתונים ובמבנים קיימים, ומאמתת את התאימות להטמעות ולקוראי נתונים קיימים של Health Connect. זו גישה נפוצה בפלטפורמות כושר.

בנוסף, סשנים בודדים כמו שחייה, רכיבה על אופניים וריצה לא מקושרים באופן מובנה ב-Health Connect, וקוראי הנתונים צריכים להסיק את הקשר בין הסשנים האלה על סמך הקרבה שלהם בזמן. מעברים בין פלחים, כמו משחייה לרכיבה על אופניים, לא מוצגים באופן מפורש.

בדוגמה הבאה אפשר לראות איך כותבים נתונים של טריאתלון:

val swimStartTime = Instant.parse("2024-08-22T08:00:00Z")
val swimEndTime = Instant.parse("2024-08-22T08:30:00Z")
val bikeStartTime = Instant.parse("2024-08-22T08:40:00Z")
val bikeEndTime = Instant.parse("2024-08-22T09:40:00Z")
val runStartTime = Instant.parse("2024-08-22T09:50:00Z")
val runEndTime = Instant.parse("2024-08-22T10:20:00Z")

val swimSession = ExerciseSessionRecord(
    startTime = swimStartTime,
    endTime = swimEndTime,
    exerciseType = ExerciseSessionRecord.EXERCISE_TYPE_SWIMMING_OPEN_WATER,
    metadata = Metadata(
        device = Device(type = Device.TYPE_WATCH)
    ),
    startZoneOffset = null,
    endZoneOffset = null,
)

val bikeSession = ExerciseSessionRecord(
    startTime = bikeStartTime,
    endTime = bikeEndTime,
    exerciseType = ExerciseSessionRecord.EXERCISE_TYPE_BIKING,
    metadata = Metadata(
        device = Device(type = Device.TYPE_WATCH)
    ),
    startZoneOffset = null,
    endZoneOffset = null,
)

val runSession = ExerciseSessionRecord(
    startTime = runStartTime,
    endTime = runEndTime,
    exerciseType = ExerciseSessionRecord.EXERCISE_TYPE_RUNNING,
    metadata = Metadata(
        device = Device(type = Device.TYPE_WATCH)
    ),
    startZoneOffset = null,
    endZoneOffset = null,
)

healthConnectClient.insertRecords(listOf(swimSession, bikeSession, runSession))
HealthConnectManager.kt

טיפול בחריגים

אפליקציית Health Connect יוצרת חריגים סטנדרטיים לפעולות CRUD כשמתגלה בעיה. האפליקציה צריכה לזהות כל אחד מהחריגים האלה ולטפל בו בצורה המתאימה.

בכל שיטה ב-HealthConnectClient מפורטים החריגים שיכולים להיזרק. באופן כללי, האפליקציה צריכה לטפל בחריגים הבאים: