כתיבת נתונים

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

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

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

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

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

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

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

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

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

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

val stepsRecord = StepsRecord(
    count = 120,
    startTime = startTime,
    endTime = endTime,
    startZoneOffset = ZoneOffset.UTC,
    endZoneOffset = ZoneOffset.UTC,
    metadata = Metadata.autoRecorded(
        device = Device(type = Device.TYPE_WATCH)
    )
)

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

אפשר לאחסן ב-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.manualEntry(
        device = Device(type = Device.TYPE_PHONE)
    )
)

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

אפליקציית 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.autoRecorded(
        device = Device(type = Device.TYPE_WATCH)
    ))

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

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

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

// Create a set of permissions for required data types
val PERMISSIONS =
    setOf(
  HealthPermission.getReadPermission(HeartRateRecord::class),
  HealthPermission.getWritePermission(HeartRateRecord::class),
  HealthPermission.getReadPermission(StepsRecord::class),
  HealthPermission.getWritePermission(StepsRecord::class)
)

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

// Create the permissions launcher
val requestPermissionActivityContract = PermissionController.createRequestPermissionResultContract()

val requestPermissions = registerForActivityResult(requestPermissionActivityContract) { granted ->
  if (granted.containsAll(PERMISSIONS)) {
    // Permissions successfully granted
  } else {
    // Lack of required permissions
  }
}

suspend fun checkPermissionsAndRun(healthConnectClient: HealthConnectClient) {
  val granted = healthConnectClient.permissionController.getGrantedPermissions()
  if (granted.containsAll(PERMISSIONS)) {
    // Permissions already granted; proceed with inserting or reading data
  } else {
    requestPermissions.launch(PERMISSIONS)
  }
}

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

כתיבת נתונים

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

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

suspend fun insertSteps(healthConnectClient: HealthConnectClient) {
    val endTime = Instant.now()
    val startTime = endTime.minus(Duration.ofMinutes(5))
    try {
        val stepsRecord = StepsRecord(
            count = 120,
            startTime = startTime,
            endTime = endTime,
            startZoneOffset = ZoneOffset.UTC,
            endZoneOffset = ZoneOffset.UTC,
            metadata = Metadata.autoRecorded(
                device = Device(type = Device.TYPE_WATCH)
            )
        )
        healthConnectClient.insertRecords(listOf(stepsRecord))
    } catch (e: Exception) {
        // Run error handling here
    }
}

עדכון נתונים

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

Metadata

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

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

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

בדוגמה הבאה אפשר לראות איך מעדכנים נתונים. לשם כך, ערכי ההפרש משעת UTC של כל רשומה מותאמים לשעון החוף הפסיפי (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
    }
}

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

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

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

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

suspend fun pullStepsFromDatastore() : 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.autoRecorded(
            clientRecordId = "Your client record ID",
            device = Device(type = Device.TYPE_WATCH)
        ),
        // Assign more parameters for this record
    )
    appStepsRecords.add(sr)
    // ...
    return appStepsRecords
}

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

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

upsertSteps(healthConnectClient, pullStepsFromDatastore())

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

אם התהליך שלכם להוספת נתונים כולל את 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.manualEntry(
        clientRecordId = "Your supplied record ID",
        clientRecordVersion = 0L, // Your supplied record version
        device = Device(type = Device.TYPE_WATCH)
    )
)

פעולות 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(java.time.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(java.time.Duration.ofMinutes(minutesBetweenSamples)),
        startZoneOffset = zoneOffset,
        endTime = sampleTime,
        endZoneOffset = zoneOffset,
        count = Random.nextLong(1, 100),
        metadata = Metadata.unknownRecordingMethod(),
    )
    sampleTime = sampleTime.plus(java.time.Duration.ofMinutes(minutesBetweenSamples))
}
healthConnectClient.insertRecords(
    stepsRecords
)

פרטים נוספים מופיעים במאמרי העזרה בנושא 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.autoRecorded(
        device = Device(type = Device.TYPE_WATCH)
    ))

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

לגבי נתונים שנאספים באופן שוטף, כמו צעדים, האפליקציה צריכה לכתוב ל-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.autoRecorded(
      device = Device(type = Device.TYPE_WATCH)
    )
)

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

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

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

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

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

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