फ़िटनेस के लक्ष्यों के साथ काम करें

Google Fit में लक्ष्य तय किए गए हैं ऐप्लिकेशन जिन्हें लोग अपने लिए सेट कर सकते हैं. इससे, लोगों को हर दिन ऐक्टिव रहने के लिए बढ़ावा मिलता है दिन. अपनी प्रोफ़ाइल में जाकर, उपयोगकर्ता यह तय कर सकते हैं कि किसी वे हार्ट पॉइंट जिन्हें टारगेट करना है मिलता है. Fit प्लैटफ़ॉर्म उनके लक्ष्य ट्रैक करता है और हर रोज़ उन्हें ट्रैक करता है के ख़िलाफ़ आवाज़ उठाएं.

लक्ष्यों की मदद से उपयोगकर्ताओं को बेहतर अनुभव दें

आपका ऐप्लिकेशन, उपयोगकर्ता के निजी टारगेट पर नज़र रखने के लिए, उनके लक्ष्यों को पढ़ सकता है. यह वीडियो और ऑडियो का इस्तेमाल ज़्यादा दिलचस्प बनाने में किया जा सकता है. शुरू करने के लिए, GoalsClient क्लाइंट के कदमों और 'हार्ट पॉइंट' के लक्ष्यों को पढ़ने के लिए किया जाता है. इसके बाद, HistoryClient ताकि क्लाइंट यह देख सकें कि वे उन लक्ष्यों के कितने करीब हैं.

Google Fit और आपके ऐप्लिकेशन के बीच स्विच करने में उपयोगकर्ताओं की मदद करने के लिए, इस डेटा का इस्तेमाल करें साथ ही, दोनों ऐप्लिकेशन पर उनकी प्रोग्रेस के बारे में लगातार जानकारी मिलेगी फ़िटनेस लक्ष्यों को हासिल करने में मदद मिलती है.

उपयोगकर्ताओं को अपडेट और अहम जानकारी देकर, उन्हें हर दिन के लक्ष्य हासिल करने के लिए प्रेरित करें जो उनकी प्रोग्रेस से जुड़ी होती हैं.

कोई लक्ष्य पढ़ें

नीचे दिए गए उदाहरण में, नया फ़िटनेस क्लाइंट बनाने और उपयोगकर्ता के 'हार्ट पॉइंट' के लक्ष्य या null.

Kotlin

private val fitnessOptions: FitnessOptions by lazy {
    FitnessOptions.builder()
        .addDataType(DataType.TYPE_HEART_POINTS, FitnessOptions.ACCESS_READ)
        .build()
}

private val goalsReadRequest: GoalsReadRequest by lazy {
    GoalsReadRequest.Builder()
        .addDataType(DataType.TYPE_HEART_POINTS)
        .build()
}

private fun getGoogleAccount(): GoogleSignInAccount =
    GoogleSignIn.getAccountForExtension(requireContext(), fitnessOptions)


private fun readGoals() {
    Fitness.getGoalsClient(requireContext(), getGoogleAccount())
        .readCurrentGoals(goalsReadRequest)
        .addOnSuccessListener { goals ->
            // There should be at most one heart points goal currently.
            goals.firstOrNull()?.apply {
                // What is the value of the goal
                val goalValue = metricObjective.value
                Log.i(TAG, "Goal value: $goalValue")

                // How is the goal measured?
                Log.i(TAG, "Objective: $objective")

                // How often does the goal repeat?
                Log.i(TAG, "Recurrence: $recurrenceDetails")
            }
        }
}

private val Goal.objective: String
    get() = when (objectiveType) {
        OBJECTIVE_TYPE_DURATION ->
            "Duration (s): ${durationObjective.getDuration(TimeUnit.SECONDS)}"
        OBJECTIVE_TYPE_FREQUENCY ->
            "Frequency : ${frequencyObjective.frequency}"
        OBJECTIVE_TYPE_METRIC ->
            "Metric : ${metricObjective.dataTypeName} - ${metricObjective.value}"
        else -> "Unknown objective"
    }

private val Goal.recurrenceDetails: String
    get() = recurrence?.let {
        val period = when (it.unit) {
            Recurrence.UNIT_DAY -> "days"
            Recurrence.UNIT_WEEK -> "weeks"
            Recurrence.UNIT_MONTH -> "months"
            else -> "Unknown"
        }
        "Every ${recurrence!!.count} $period"
    } ?: "Does not repeat"

Java

private final FitnessOptions fitnessOptions = FitnessOptions.builder()
            .addDataType(DataType.TYPE_HEART_POINTS, FitnessOptions.ACCESS_READ)
            .build();


private final GoalsReadRequest goalsReadRequest = new GoalsReadRequest.Builder()
            .addDataType(DataType.TYPE_HEART_POINTS)
            .build();

private GoogleSignInAccount getGoogleAccount() {
    GoogleSignIn.getAccountForExtension(getApplicationContext(), fitnessOptions);
}


private void readGoals() {
    Fitness.getGoalsClient(getApplicationContext(), getGoogleAccount())
            .readCurrentGoals(goalsReadRequest)
            .addOnSuccessListener(goals -> {
                // There should be at most one heart points goal currently.
                Optional<Goal> optionalGoal = goals.stream().findFirst();
                if (optionalGoal.isPresent()) {
                    // What is the value of the goal
                    double goalValue = optionalGoal.get().getMetricObjective().getValue();
                    Log.i(TAG, "Goal value: $goalValue");

                    // How is the goal measured?
                    Log.i(TAG, "Objective: ${getObjective(optionalGoal.get())}");

                    // How often does the goal repeat?
                    Log.i(TAG, "Recurrence: ${getRecurrenceDetails(optionalGoal.get())}");
                }

    });
}

private String getObjective(Goal goal) {
    switch (goal.getObjectiveType()) {
        case OBJECTIVE_TYPE_DURATION:
            return "Duration (s): ${goal.getDurationObjective().getDuration(TimeUnit.SECONDS)}";
        case OBJECTIVE_TYPE_FREQUENCY:
            return "Frequency : ${goal.getFrequencyObjective().getFrequency()}";
        case OBJECTIVE_TYPE_METRIC:
            return "Metric : ${goal.getMetricObjective().getDataTypeName()} - ${goal.getMetricObjective().getValue()}";
        default:
            return "Unknown objective";
    }
}

private String getRecurrenceDetails(Goal goal) {
    Goal.Recurrence recurrence = goal.getRecurrence();
    if (recurrence == null) {
        return "Does not repeat";
    }

    StringBuilder recurrenceMessage = new StringBuilder("Every ${recurrence.getCount()}");

    switch (recurrence.getUnit()) {
        case UNIT_DAY:
            recurrenceMessage.append("days");
            break;
        case UNIT_WEEK:
            recurrenceMessage.append("weeks");
            break;
        case UNIT_MONTH:
            recurrenceMessage.append("months");
            break;
        default:
            recurrenceMessage.delete(0, recurrenceMessage.length());
            recurrenceMessage.append("Unknown");
            break;
    }

    return recurrenceMessage.toString();
}

प्रोग्रेस देखें

उपयोगकर्ता के 'हार्ट पॉइंट' का लक्ष्य हासिल करने के बाद, आप उनकी प्रोग्रेस देखने के लिए, HistoryClient पर टैप करें. नीचे दिए गए उदाहरण में, यह पता करने का तरीका बताया गया है कि उपयोगकर्ता के पास कितने 'हार्ट पॉइंट' हैं.

ध्यान दें: किसी लक्ष्य की समयावधि, उसकी फ़्रीक्वेंसी के आधार पर तय की जाती है. इसके लिए उदाहरण के लिए, अगर हर दिन के लक्ष्य को पूरा करना है, तो इसके लिए मौजूदा समय का इस्तेमाल किया जाता है. शुरू और खत्म होता है. अगर हर दिन का लक्ष्य तय किया गया है, तो कोड को इस तरह से आसान बनाया जा सकता है HistoryClient.readDailyTotal() का इस्तेमाल किया जा रहा है के बजाय HistoryClient.readData(). इस उदाहरण में सिर्फ़ HistoryClient.readData() का इस्तेमाल करके दिखाया गया है कि 'लक्ष्य ऑब्जेक्ट' कैसे काम कर सकते हैं का इस्तेमाल, बार-बार होने की मौजूदा अवधि के शुरू और खत्म होने का समय पता करने के लिए किया जा सकता है. इसके लिए ज़रूरी है कि प्रोग्रेस के लिए क्वेरी.

Kotlin

val current = Calendar.getInstance()
val request = DataReadRequest.Builder()
    .read(DataType.TYPE_HEART_POINTS)
    .setTimeRange(
        goal.getStartTime(current, TimeUnit.NANOSECONDS),
        goal.getEndTime(current, TimeUnit.NANOSECONDS),
        TimeUnit.NANOSECONDS
    )
    .build()

Fitness.getHistoryClient(requireContext(), getGoogleAccount())
    .readData(request)
    .addOnSuccessListener { response ->
        val heartPointsSet = response.dataSets.first()
        val totalHeartPoints = heartPointsSet.dataPoints.sumBy {
            it.getValue(Field.FIELD_INTENSITY).asFloat().toInt()
        }
        Log.i(TAG, "Total heart points: $totalHeartPoints")
    }

Java

Calendar current = Calendar.getInstance();
DataReadRequest request = new DataReadRequest.Builder()
        .read(DataType.TYPE_HEART_POINTS)
        .setTimeRange(
                goal.getStartTime(current, TimeUnit.NANOSECONDS),
                goal.getEndTime(current, TimeUnit.NANOSECONDS),
                TimeUnit.NANOSECONDS
        )
        .build();


Fitness.getHistoryClient(getApplicationContext(), getGoogleAccount())
        .readData(request)
        .addOnSuccessListener(response -> {
            Optional<DataSet> heartPointsSet = response.getDataSets().stream().findFirst();
            if (heartPointsSet.isPresent()) {
                int totalHeartPoints = 0;
                for (DataPoint dp : heartPointsSet.get().getDataPoints()) {
                    totalHeartPoints += (int) dp.getValue(Field.FIELD_INTENSITY).asFloat();
                }

                Log.i(TAG, "Total heart points: $totalHeartPoints");
            }
        });

प्रतिशत के रूप में प्रोग्रेस की गिनती करना

अगर कुल संख्या को जांच की प्रोग्रेस के उदाहरण से भाग दिया जाता है, तो कोई लक्ष्य पढ़ें उदाहरण में दिए गए टारगेट के हिसाब से, प्रतिशत के रूप में लक्ष्य की ओर बढ़ें.

Kotlin

private fun calculateProgressPercentage(goal: Goal, response: DataReadResponse): Double {
    val goalValue = goal.metricObjective.value
    val currentTotal = response.dataSets.first().dataPoints.sumBy {
        it.getValue(Field.FIELD_INTENSITY).asFloat().toInt()
    }

    return (currentTotal.div(goalValue)).times(100.0)
}

Java

private double calculateProgressPercentage(Goal goal, DataReadResponse response) {
    double goalValue = goal.getMetricObjective().getValue();
    Optional<DataSet> firstDataSet = response.getDataSets().stream().findFirst();
    if (!(firstDataSet.isPresent())) {
        return NaN;
    }
    double currentTotal = 0;
    for (DataPoint dp : firstDataSet.get().getDataPoints()) {
        currentTotal += (int)dp.getValue(Field.FIELD_INTENSITY).asFloat();
    }

    return (currentTotal / goalValue) * 100.0;
}