כתיבת נתונים

המדריך הזה תואם לגרסה 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. המאפיינים הבאים רלוונטיים לסנכרון:

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

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

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

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

אם אתם משתמשים בערכים האופציונליים של מזהה רשומת לקוח וגרסת רשומת לקוח, מומלץ להשתמש ב-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 בכל פעם שיש שינויים, וכך נמנעים מקרים לא צפויים של דריסת נתונים. לכן, צריך לספק לו ערך גבוה יותר באופן ידני.

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

אפליקציות יכולות לכתוב ב-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 דקות.

טבלה 1: הנחיות לכתיבת נתונים

סוג הנתונים

היחידה

צפוי

דוגמה

צעדים

צעדים

כל דקה

‫23:14 - 23:15 - 5 צעדים

‫23:16 - 23:17 - 22 צעדים

‫23:17 - 23:18 - 8 צעדים

StepsCadence

צעדים בדקה

כל דקה

‫23:14 - 23:15 - 5 צעדים לדקה

‫23:16 - 23:17 - 22 צעדים לדקה

‫23:17 - 23:18 - 8 צעדים לדקה

דחיפות כיסא גלגלים

דחיפות

כל דקה

‫23:14 - 23:15 - 5 דחיפות

‫23:16 - 23:17 - 22 הודעות

‫23:17 – 23:18 – 8 הודעות פוש

ActiveCaloriesBurned

קלוריות

כל 15 דקות

‫23:15 - 23:30 - 2 קלוריות

‫23:30 - 23:45 - 25 קלוריות

‫23:45 - 00:00 - 5 קלוריות

TotalCaloriesBurned

קלוריות

כל 15 דקות

‫23:15 - 23:30 - 16 קלוריות

‫23:30 - 23:45 – 16 קלוריות

‫23:45 - 00:00 - 16 קלוריות

מרחק

ק"מ לדקה

כל דקה

‫23:14-23:15 – 0.008 ק"מ

‫23:16 - 23:16 - 0.021 ק"מ

‫23:17 - 23:18 - 0.012 ק"מ

ElevationGained

מטר

כל דקה

‫20:36 - 20:37 - 3.048m

‫20:39 - 20:40 - 3.048m

‫23:23 - 23:24 - 9.144m

FloorsClimbed

קומות

כל דקה

‫23:14 - 23:15 - 5 קומות

‫23:16 - 23:16 - 22 קומות

‫23:17 - 23:18 - 8 קומות

HeartRate

bpm

4 פעמים בדקה

‫6:11:15 – 55 פעימות בדקה

‫6:11:30 – 56 פעימות בדקה

‫6:11:45 - 56 פעימות בדקה

‫6:12:00 – 55 פעימות בדקה

HeartRateVariabilityRmssd

אלפיות שנייה

כל דקה

‫6:11am - 23 ms

RespiratoryRate

נשימות בדקה

כל דקה

‫23:14 עד 23:15 – 60 נשימות בדקה

‫23:16 - 23:16 - 62 נשימות בדקה

‫23:17 - 23:18 - 64 נשימות בדקה

OxygenSaturation

%

כל שעה

‫6:11 - 95.208%

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

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

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

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

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

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

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

טבלה 2: הנחיות לכתיבת נתונים במהלך אימון

סוג הנתונים

היחידה

צפוי

המשך יום נעים

דוגמה

צעדים

צעדים

כל דקה

כל שנייה

‫23:14-23:15 – 5 צעדים

‫23:16 - 23:17 - 22 צעדים

‫23:17 - 23:18 - 8 צעדים

StepsCadence

צעדים בדקה

כל דקה

כל שנייה

‫23:14-23:15 – 35 צעדים לדקה

‫23:16 - 23:17 - 37 צעדים לדקה

‫23:17 - 23:18 - 40 צעדים לדקה

דחיפות כיסא גלגלים

דחיפות

כל דקה

כל שנייה

‫23:14-23:15 - 5 הודעות

‫23:16 - 23:17 - 22 הודעות

‫23:17 – 23:18 – 8 הודעות פוש

CyclingPedalingCadence

נשימות בדקה

כל דקה

כל שנייה

‫23:14-23:15 – 65 סיבובים לדקה

‫23:16 - 23:17 - 70 סל"ד

‫23:17 - 23:18 - 68 סיבובים לדקה

כוח

ואט

כל דקה

כל שנייה

‫23:14-23:15 – 250 ואט

‫23:16 - 23:17 - 255 ואט

‫23:17 - 23:18 - 245 ואט

מהירות

ק"מ לדקה

כל דקה

כל שנייה

‫23:14-23:15 – 0.3 ק"מ לדקה

‫23:16 - 23:17 - 0.4 ק"מ לדקה

‫23:17 - 23:18 -0.4 ק"מ לדקה

מרחק

ק"מ/מ'

כל דקה

כל שנייה

‫23:14-23:15 – 0.008 ק"מ

‫23:16 - 23:16 - 0.021 ק"מ

‫23:17 - 23:18 - 0.012 ק"מ

ActiveCaloriesBurned

קלוריות

כל דקה

כל שנייה

‫23:14-23:15 – 20 קלוריות

‫23:16 - 23:17 - 20 קלוריות

‫23:17 - 23:18 - 25 קלוריות

TotalCaloriesBurned

קלוריות

כל דקה

כל שנייה

‫23:14-23:15 – 36 קלוריות

‫23:16 - 23:17 - 36 קלוריות

‫23:17 - 23:18 - 41 קלוריות

ElevationGained

מטר

כל דקה

כל שנייה

‫20:36 - 20:37 - 3.048m

‫20:39 - 20:40 - 3.048m

‫23:23 - 23:24 - 9.144m

ExerciseRoutes

lat/lng/alt

כל 3-5 שניות

כל שנייה

HeartRate

bpm

4 פעמים בדקה

כל שנייה

‫23:14-23:15 – 150 פעימות בדקה

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

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

סוג הנתונים

היחידה

דוגמאות צפויות

דוגמה

שלבי השינה

שלב

תקופת זמן מפורטת לכל שלב שינה

‫23:46 - 23:50 - ערות

‫23:50 עד 23:56 – שינה קלה

‫23:56 - 00:16 - שינה עמוקה

RestingHeartRate

bpm

ערך יומי יחיד (צפוי בשעות הבוקר המוקדמות)

‫6:11 – 60 פעימות לדקה

OxygenSaturation

%

ערך יומי יחיד (צפוי בשעות הבוקר המוקדמות)

‫6:11 - 95.208%

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

הגישה הזו משתמשת בסוגי נתונים ובמבנים קיימים, והיא מאמתת את התאימות להטמעות ולקוראי נתונים קיימים של 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 מפורטים החריגים שיכולים להיות מושלכים. באופן כללי, האפליקציה צריכה לטפל בחריגים הבאים:

טבלה 1: חריגים ב-Health Connect ושיטות מומלצות
חריג תיאור שיטה מומלצת
IllegalStateException אחד מהתרחישים הבאים התרחש:

  • השירות Health Connect לא זמין.
  • הבקשה לא תקינה. לדוגמה, בקשה מצטברת בקטגוריות תקופתיות שבהן נעשה שימוש באובייקט Instant בשביל timeRangeFilter.

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

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

RemoteException אירעו שגיאות בשירות הבסיסי שאליו ה-SDK מתחבר, או בתקשורת איתו.

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

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

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