React Native 센서 데이터 집계: 재시작과 중복 전달에도 값을 어떻게 유지하는가

원본 의미       변화량 / 누적 counter / 시간 구간 합계
기준 정보       재부팅 세대 / 구간 시작·종료 / 마지막 처리 지점
영속 기록       제품 합계 + 마지막 기준 정보를 함께 저장
중복 전달       이미 처리한 기준이면 합계 변화 0
새 기준         첫 값은 baseline(첫 기준값)으로만 저장한 뒤 다음 값부터 계산

TYPE_STEP_COUNTER   100 → 101 → 103    변화량은 1, 2
TYPE_STEP_DETECTOR  1 → 1 → 1          각 사건 자체가 한 걸음

import React, { useState } from 'react'
import { Button, SafeAreaView, StyleSheet, Text, View } from 'react-native'
import AsyncStorage from '@react-native-async-storage/async-storage'
 
const USE_CHECKPOINT_DELTA = false
const STATE_KEY = '@sensor/step-counter-aggregate'
 
type CounterReading = {
  epoch: string
  total: number
}
 
type AggregateState = {
  steps: number
  lastEpoch: string | null
  lastCounter: number | null
}
 
type Reduction = {
  state: AggregateState
  decision: string
}
 
const INITIAL_STATE: AggregateState = {
  steps: 0,
  lastEpoch: null,
  lastCounter: null,
}
 
const BOOT_A: CounterReading[] = [
  { epoch: 'boot-A', total: 100 },
  { epoch: 'boot-A', total: 101 },
  { epoch: 'boot-A', total: 101 },
  { epoch: 'boot-A', total: 103 },
]
 
const REPLAY_LAST: CounterReading[] = [{ epoch: 'boot-A', total: 103 }]
 
const BOOT_B: CounterReading[] = [
  { epoch: 'boot-B', total: 2 },
  { epoch: 'boot-B', total: 5 },
]
 
function isAggregateState(input: unknown): input is AggregateState {
  if (typeof input !== 'object' || input === null) {
    return false
  }
 
  const steps = 'steps' in input ? input.steps : undefined
  const lastEpoch = 'lastEpoch' in input ? input.lastEpoch : undefined
  const lastCounter = 'lastCounter' in input ? input.lastCounter : undefined
 
  if (typeof steps !== 'number' || !Number.isSafeInteger(steps) || steps < 0) {
    return false
  }
 
  const epochIsValid = typeof lastEpoch === 'string' || lastEpoch === null
  const counterIsValid =
    lastCounter === null ||
    (typeof lastCounter === 'number' &&
      Number.isSafeInteger(lastCounter) &&
      lastCounter >= 0)
 
  return epochIsValid && counterIsValid
}
 
async function loadState(): Promise<AggregateState> {
  const raw = await AsyncStorage.getItem(STATE_KEY)
 
  if (raw === null) {
    return INITIAL_STATE
  }
 
  try {
    const input: unknown = JSON.parse(raw)
    return isAggregateState(input) ? input : INITIAL_STATE
  } catch {
    return INITIAL_STATE
  }
}
 
function addRawReadingValue(
  current: AggregateState,
  reading: CounterReading,
): Reduction {
  return {
    state: {
      steps: current.steps + reading.total,
      lastEpoch: reading.epoch,
      lastCounter: reading.total,
    },
    decision: `${reading.epoch}:${reading.total} 전체를 다시 더함`,
  }
}
 
function addDeltaFromCheckpoint(
  current: AggregateState,
  reading: CounterReading,
): Reduction {
  if (current.lastEpoch !== reading.epoch || current.lastCounter === null) {
    return {
      state: {
        steps: current.steps,
        lastEpoch: reading.epoch,
        lastCounter: reading.total,
      },
      decision: `${reading.epoch}:${reading.total} 새 baseline`,
    }
  }
 
  if (reading.total === current.lastCounter) {
    return {
      state: current,
      decision: `${reading.epoch}:${reading.total} 중복, +0`,
    }
  }
 
  if (reading.total < current.lastCounter) {
    return {
      state: current,
      decision: `${reading.epoch}:${reading.total} 오래되거나 잘못된 값, 무시`,
    }
  }
 
  const delta = reading.total - current.lastCounter
 
  return {
    state: {
      steps: current.steps + delta,
      lastEpoch: reading.epoch,
      lastCounter: reading.total,
    },
    decision: `${reading.epoch}:${reading.total} 변화량 +${delta}`,
  }
}
 
async function persistReading(reading: CounterReading): Promise<Reduction> {
  const current = await loadState()
  const reduction = USE_CHECKPOINT_DELTA
    ? addDeltaFromCheckpoint(current, reading)
    : addRawReadingValue(current, reading)
 
  if (reduction.state !== current) {
    await AsyncStorage.setItem(STATE_KEY, JSON.stringify(reduction.state))
  }
 
  return reduction
}
 
let operationChain: Promise<void> = Promise.resolve()
 
function runSequentially<T>(operation: () => Promise<T>): Promise<T> {
  const result = operationChain.then(operation, operation)
  operationChain = result.then(
    () => undefined,
    () => undefined,
  )
  return result
}
 
export default function App() {
  const [snapshot, setSnapshot] = useState(INITIAL_STATE)
  const [trace, setTrace] = useState('아직 전달하지 않음')
  const [busy, setBusy] = useState(false)
 
  async function run(operation: () => Promise<void>) {
    setBusy(true)
 
    try {
      await operation()
    } catch {
      setTrace('fixture 실행 오류')
    } finally {
      setBusy(false)
    }
  }
 
  async function resetFixture() {
    await run(async () => {
      await runSequentially(async () => {
        await AsyncStorage.removeItem(STATE_KEY)
      })
      setSnapshot(INITIAL_STATE)
      setTrace('fixture 초기화 완료')
    })
  }
 
  async function inspectStoredState() {
    await run(async () => {
      const stored = await runSequentially(loadState)
      setSnapshot(stored)
      setTrace('저장 상태 읽기 완료')
    })
  }
 
  async function playReadings(readings: CounterReading[]) {
    await run(async () => {
      const decisions: string[] = []
      let latest = await runSequentially(loadState)
 
      for (const reading of readings) {
        const reduction = await runSequentially(() => persistReading(reading))
        latest = reduction.state
        decisions.push(reduction.decision)
      }
 
      setSnapshot(latest)
      setTrace(decisions.join(' / '))
    })
  }
 
  return (
    <SafeAreaView style={styles.screen}>
      <Text style={styles.title}>걸음 counter 집계 fixture</Text>
      <Text>mode: {USE_CHECKPOINT_DELTA ? 'checkpoint-delta' : 'raw-sum'}</Text>
      <Text>제품 합계: {snapshot.steps}</Text>
      <Text>마지막 세대: {snapshot.lastEpoch ?? '없음'}</Text>
      <Text>마지막 counter: {snapshot.lastCounter ?? '없음'}</Text>
      <Text>판단: {trace}</Text>
      <View style={styles.actions}>
        <Button title="fixture 초기화" disabled={busy} onPress={() => void resetFixture()} />
        <Button
          title="boot-A 100→101→101→103"
          disabled={busy}
          onPress={() => void playReadings(BOOT_A)}
        />
        <Button
          title="boot-A 103 다시 전달"
          disabled={busy}
          onPress={() => void playReadings(REPLAY_LAST)}
        />
        <Button
          title="boot-B 2→5"
          disabled={busy}
          onPress={() => void playReadings(BOOT_B)}
        />
        <Button
          title="저장 상태 읽기"
          disabled={busy}
          onPress={() => void inspectStoredState()}
        />
      </View>
    </SafeAreaView>
  )
}
 
const styles = StyleSheet.create({
  screen: { flex: 1, padding: 16, gap: 12 },
  title: { fontSize: 22, fontWeight: '700' },
  actions: { gap: 8 },
})

mode: raw-sum
제품 합계: 405
마지막 세대: boot-A
마지막 counter: 103
판단: boot-A:100 전체를 다시 더함 / boot-A:101 전체를 다시 더함 / boot-A:101 전체를 다시 더함 / boot-A:103 전체를 다시 더함

const USE_CHECKPOINT_DELTA = true

mode: checkpoint-delta
제품 합계: 3
마지막 세대: boot-A
마지막 counter: 103
판단: boot-A:100 새 baseline / boot-A:101 변화량 +1 / boot-A:101 중복, +0 / boot-A:103 변화량 +2

제품 합계: 3
마지막 세대: boot-A
마지막 counter: 103
판단: boot-A:103 중복, +0

제품 합계: 6
마지막 세대: boot-B
마지막 counter: 5
판단: boot-B:2 새 baseline / boot-B:5 변화량 +3

Android TYPE_STEP_COUNTER
  구분 기준: 기기 재부팅 세대
  원본 값: 그 세대에서 활성화된 뒤 누적 counter
  병합 방법: 같은 세대의 마지막 counter와 차이
 
iOS CMPedometerData
  구분 기준: 응답 startDate와 endDate가 나타내는 실제 시간 구간
  원본 값: 해당 구간의 numberOfSteps
  병합 방법: 같은 고정 구간은 교체하거나, 확인된 다음 구간만 더함

Android adapter
  입력: BOOT_COUNT + TYPE_STEP_COUNTER values[0]
  출력: { kind: 'cumulative', epoch, total }
 
iOS adapter
  입력: CMPedometerData startDate, endDate, numberOfSteps
  출력: { kind: 'interval', startAt, endAt, steps }

원본 의미       변화량 / 누적 counter / 시간 구간 합계 중 무엇인가
단위·기준       단위, 원점, 초기화 조건, 시작·종료 시각은 무엇인가
기능 상태       권한 거절, 센서 없음, 아직 측정 전과 실제 0을 구분하는가
영속 checkpoint 제품 합계와 마지막 기준 정보를 어디에 함께 저장하는가
중복·역순       같은 값과 오래된 값이 오면 합계를 바꾸지 않는가
동시 처리       읽기→계산→쓰기를 한 처리 입구나 하나로 묶은 저장 연산으로 보호하는가
플랫폼 연결 층  Android counter와 iOS 시간 구간 의미를 보존하는가
복구            앱 재시작·기기 재부팅·날짜 경계 뒤 기준을 어떻게 다시 잡고, iOS 요청·응답 시작 시각의 공백과 7일 한계를 어떻게 표시하는가
관찰            원본 기준, 계산 변화량, 저장 성공과 오류를 민감 정보 없이 남기는가
실기기          지원 기기에서 권한·실제 걸음·지연·재시작을 확인했는가

문제       누적 counter 100, 101, 101, 103을 전달될 때마다 더해 405가 됨
오판       센서 측정값은 언제나 이번 변화량임
관찰       Reload 뒤 103 재전달로 합계가 508까지 다시 증가
원인       제품 합계와 마지막 반영 기준을 함께 저장하지 않음
행동       세대+counter checkpoint 저장, 같은 세대에서는 차이만 반영
재부팅     새 세대 첫 값은 baseline, 다음 값부터 변화량 계산
iOS        응답 startDate·endDate 구간으로 병합하고 7일 초과·부분 응답은 공백으로 표시
경계       fixture는 상태 계산을 증명하고 실제 센서·권한·지연은 실기기 검증