diff --git a/src/components/OpenActivity.vue b/src/components/OpenActivity.vue
index fc75ef9..3ecb0ae 100644
--- a/src/components/OpenActivity.vue
+++ b/src/components/OpenActivity.vue
@@ -269,7 +269,7 @@ import { Summary } from '@/spec/summary'
 </template>
 
 <script lang="ts">
-import { ActivityFile, Lap, Record, Session } from '@/spec/activity'
+import { ActivityFile, Lap, Record, SPORT_UNKNOWN, Session } from '@/spec/activity'
 import { Feature } from 'ol'
 import { GeoJSON } from 'ol/format'
 import { shallowRef } from 'vue'
@@ -335,6 +335,8 @@ export default {
           case 'Walking':
           case 'Running':
           case 'Swimming':
+          case 'Other':
+          case SPORT_UNKNOWN:
             return true
         }
       }
diff --git a/src/wasm/activity-service/activity/creator.go b/src/wasm/activity-service/activity/creator.go
index c585489..a28ccc0 100644
--- a/src/wasm/activity-service/activity/creator.go
+++ b/src/wasm/activity-service/activity/creator.go
@@ -26,7 +26,7 @@ func (c *Creator) ToMap() map[string]any {
 	if c.Product != nil {
 		m["product"] = *c.Product
 	}
-	if c.TimeCreated != (time.Time{}) {
+	if !c.TimeCreated.IsZero() {
 		m["timeCreated"] = c.TimeCreated.Format(time.RFC3339)
 	}
 
diff --git a/src/wasm/activity-service/activity/fit/listener.go b/src/wasm/activity-service/activity/fit/listener.go
index 554b155..ac188e0 100644
--- a/src/wasm/activity-service/activity/fit/listener.go
+++ b/src/wasm/activity-service/activity/fit/listener.go
@@ -144,7 +144,7 @@ func isBelongToSession(timestamp, sessionStartTime, sessionEndTime time.Time) bo
 	if timestamp.Equal(sessionStartTime) {
 		return true
 	}
-	if sessionEndTime == (time.Time{}) && timestamp.After(sessionStartTime) { // Last Session has no EndTime
+	if sessionEndTime.IsZero() && timestamp.After(sessionStartTime) { // Last Session has no EndTime
 		return true
 	} else if timestamp.After(sessionStartTime) && timestamp.Before(sessionEndTime) {
 		return true
diff --git a/src/wasm/activity-service/activity/gpx/record.go b/src/wasm/activity-service/activity/gpx/record.go
index e9227ac..417f611 100644
--- a/src/wasm/activity-service/activity/gpx/record.go
+++ b/src/wasm/activity-service/activity/gpx/record.go
@@ -22,11 +22,11 @@ func NewRecord(trkpt *schema.Waypoint, prevRec *activity.Record) *activity.Recor
 	var pointDistance float64 // distance between two coordinates
 	ext := trkpt.TrackPointExtension
 	if ext != nil {
-		if prevRec != nil && prevRec.Distance != nil && ext.Distance != nil {
-			pointDistance = *ext.Distance - *prevRec.Distance
-		}
 		if ext.Distance != nil {
 			rec.Distance = ext.Distance
+			if prevRec != nil && prevRec.Distance != nil {
+				pointDistance = *ext.Distance - *prevRec.Distance
+			}
 		}
 		rec.Cadence = ext.Cadence
 		rec.HeartRate = ext.HeartRate
@@ -54,7 +54,7 @@ func NewRecord(trkpt *schema.Waypoint, prevRec *activity.Record) *activity.Recor
 		rec.Distance = kit.Ptr(prevDist + pointDistance)
 	}
 
-	if prevRec != nil && pointDistance > 0 {
+	if pointDistance != 0 {
 		elapsed := rec.Timestamp.Sub(prevRec.Timestamp).Seconds()
 		if elapsed > 0 {
 			speed := pointDistance / elapsed
diff --git a/src/wasm/activity-service/activity/gpx/service.go b/src/wasm/activity-service/activity/gpx/service.go
index 9ce40c1..23fae19 100644
--- a/src/wasm/activity-service/activity/gpx/service.go
+++ b/src/wasm/activity-service/activity/gpx/service.go
@@ -113,6 +113,10 @@ func (s *service) Decode(ctx context.Context, r io.Reader) ([]activity.Activity,
 		session.Laps = laps
 
 		sessions = append(sessions, session)
+
+		if act.Creator.TimeCreated.IsZero() {
+			act.Creator.TimeCreated = session.StartTime
+		}
 	}
 
 	if len(sessions) == 0 {
diff --git a/src/wasm/activity-service/activity/lap.go b/src/wasm/activity-service/activity/lap.go
index e2bb8f4..ca56cb1 100644
--- a/src/wasm/activity-service/activity/lap.go
+++ b/src/wasm/activity-service/activity/lap.go
@@ -150,13 +150,13 @@ func NewLapFromSession(session *Session) *Lap {
 func (l *Lap) ToMap() map[string]any {
 	m := map[string]any{}
 
-	if l.Timestamp != (time.Time{}) {
+	if !l.Timestamp.IsZero() {
 		m["timestamp"] = l.Timestamp.Format(time.RFC3339)
 	}
-	if l.StartTime != (time.Time{}) {
+	if !l.StartTime.IsZero() {
 		m["startTime"] = l.StartTime.Format(time.RFC3339)
 	}
-	if l.EndTime != (time.Time{}) {
+	if !l.EndTime.IsZero() {
 		m["endTime"] = l.EndTime.Format(time.RFC3339)
 	}
 
diff --git a/src/wasm/activity-service/activity/record.go b/src/wasm/activity-service/activity/record.go
index 0c02c92..7c9cc41 100644
--- a/src/wasm/activity-service/activity/record.go
+++ b/src/wasm/activity-service/activity/record.go
@@ -22,7 +22,7 @@ type Record struct {
 func (r *Record) ToMap() map[string]any {
 	m := map[string]any{}
 
-	if r.Timestamp != (time.Time{}) {
+	if !r.Timestamp.IsZero() {
 		m["timestamp"] = r.Timestamp.Format(time.RFC3339)
 	}
 	if r.PositionLat != nil {
diff --git a/src/wasm/activity-service/activity/session.go b/src/wasm/activity-service/activity/session.go
index 8efbb65..134bdb0 100644
--- a/src/wasm/activity-service/activity/session.go
+++ b/src/wasm/activity-service/activity/session.go
@@ -144,13 +144,13 @@ func NewSessionFromLaps(laps []*Lap, sport string) *Session {
 func (s *Session) ToMap() map[string]any {
 	m := map[string]any{}
 
-	if s.Timestamp != (time.Time{}) {
+	if !s.Timestamp.IsZero() {
 		m["timestamp"] = s.Timestamp.Format(time.RFC3339)
 	}
-	if s.StartTime != (time.Time{}) {
+	if !s.StartTime.IsZero() {
 		m["startTime"] = s.StartTime.Format(time.RFC3339)
 	}
-	if s.EndTime != (time.Time{}) {
+	if !s.EndTime.IsZero() {
 		m["endTime"] = s.EndTime.Format(time.RFC3339)
 	}
 	if s.Sport != "" {
diff --git a/src/wasm/activity-service/activity/tcx/record.go b/src/wasm/activity-service/activity/tcx/record.go
new file mode 100644
index 0000000..b15c0c7
--- /dev/null
+++ b/src/wasm/activity-service/activity/tcx/record.go
@@ -0,0 +1,40 @@
+package tcx
+
+import (
+	"github.com/muktihari/openactivity-fit/activity"
+	"github.com/muktihari/openactivity-fit/activity/tcx/schema"
+)
+
+func NewRecord(trackpoint *schema.Trackpoint, prevRec *activity.Record) *activity.Record {
+	if trackpoint == nil {
+		return nil
+	}
+
+	rec := &activity.Record{
+		Timestamp: trackpoint.Time,
+		Distance:  trackpoint.DistanceMeters,
+		Altitude:  trackpoint.AltitudeMeters,
+		Cadence:   trackpoint.Cadence,
+		HeartRate: trackpoint.HeartRateBpm,
+	}
+
+	if trackpoint.Position != nil {
+		rec.PositionLat = &trackpoint.Position.LatitudeDegrees
+		rec.PositionLong = &trackpoint.Position.LongitudeDegrees
+	}
+
+	var pointDistance float64
+	if prevRec != nil && prevRec.Distance != nil && rec.Distance != nil {
+		pointDistance = *rec.Distance - *prevRec.Distance
+	}
+
+	if pointDistance != 0 {
+		elapsed := rec.Timestamp.Sub(prevRec.Timestamp).Seconds()
+		if elapsed > 0 {
+			speed := pointDistance / elapsed
+			rec.Speed = &speed
+		}
+	}
+
+	return rec
+}
diff --git a/src/wasm/activity-service/activity/tcx/schema/activity.go b/src/wasm/activity-service/activity/tcx/schema/activity.go
new file mode 100644
index 0000000..114f588
--- /dev/null
+++ b/src/wasm/activity-service/activity/tcx/schema/activity.go
@@ -0,0 +1,102 @@
+package schema
+
+import (
+	"encoding/xml"
+	"time"
+)
+
+type ActivityList struct {
+	Activity *Activity `xml:"Activity,omitempty"`
+}
+
+var _ xml.Unmarshaler = &ActivityList{}
+
+func (a *ActivityList) UnmarshalXML(dec *xml.Decoder, se xml.StartElement) error {
+	for {
+		token, err := dec.Token()
+		if err != nil {
+			return err
+		}
+
+		switch elem := token.(type) {
+		case xml.StartElement:
+			switch elem.Name.Local {
+			case "Activity":
+				var activity Activity
+				if err := activity.UnmarshalXML(dec, elem); err != nil {
+					return err
+				}
+				a.Activity = &activity
+			}
+		case xml.EndElement:
+			if elem == se.End() {
+				return nil
+			}
+		}
+	}
+}
+
+type Activity struct {
+	Sport   string        `xml:"Sport,attr"`
+	ID      time.Time     `xml:"Id"`
+	Laps    []ActivityLap `xml:"Lap"`
+	Notes   string        `xml:"Notes,omitempty"`
+	Creator *Device       `xml:"Creator,omitempty"`
+}
+
+var _ xml.Unmarshaler = &ActivityList{}
+
+func (a *Activity) UnmarshalXML(dec *xml.Decoder, se xml.StartElement) error {
+	for i := range se.Attr {
+		attr := &se.Attr[i]
+
+		switch attr.Name.Local {
+		case "Sport":
+			a.Sport = attr.Value
+		}
+	}
+
+	var targetCharData string
+	for {
+		token, err := dec.Token()
+		if err != nil {
+			return err
+		}
+
+		switch elem := token.(type) {
+		case xml.StartElement:
+			switch elem.Name.Local {
+			case "Lap":
+				var activityLap ActivityLap
+				if err := activityLap.UnmarshalXML(dec, elem); err != nil {
+					return err
+				}
+				a.Laps = append(a.Laps, activityLap)
+			case "Creator":
+				var device Device
+				if err := device.UnmarshalXML(dec, elem); err != nil {
+					return err
+				}
+				a.Creator = &device
+			default:
+				targetCharData = elem.Name.Local
+			}
+		case xml.CharData:
+			switch targetCharData {
+			case "Id":
+				t, err := time.Parse(time.RFC3339, string(elem))
+				if err != nil {
+					return err
+				}
+				a.ID = t
+			case "Notes":
+				a.Notes = string(elem)
+			}
+			targetCharData = ""
+		case xml.EndElement:
+			if elem == se.End() {
+				return nil
+			}
+		}
+	}
+}
diff --git a/src/wasm/activity-service/activity/tcx/schema/author.go b/src/wasm/activity-service/activity/tcx/schema/author.go
new file mode 100644
index 0000000..5d3baef
--- /dev/null
+++ b/src/wasm/activity-service/activity/tcx/schema/author.go
@@ -0,0 +1,216 @@
+package schema
+
+import (
+	"encoding/xml"
+	"strconv"
+)
+
+type Application struct {
+	Name       string `xml:"Name"`
+	Build      *Build `xml:"Build"`
+	LangID     string `xml:"LangID"`     // Specifies the two character ISO 693-1 language id that identifies the installed language of this application. see http://www.loc.gov/standards/iso639-2/ for appropriate ISO identifiers
+	PartNumber string `xml:"PartNumber"` // The formatted XXX-XXXXX-XX Garmin part number of a PC application.
+}
+
+var _ xml.Unmarshaler = &Application{}
+
+func (a *Application) UnmarshalXML(dec *xml.Decoder, se xml.StartElement) error {
+	var targetCharData string
+	for {
+		token, err := dec.Token()
+		if err != nil {
+			return err
+		}
+
+		switch elem := token.(type) {
+		case xml.StartElement:
+			switch elem.Name.Local {
+			case "Build":
+				var build Build
+				if err := build.UnmarshalXML(dec, elem); err != nil {
+					return err
+				}
+				a.Build = &build
+
+			default:
+				targetCharData = elem.Name.Local
+			}
+		case xml.CharData:
+			switch targetCharData {
+			case "Name":
+				a.Name = string(elem)
+			case "LangID":
+				a.LangID = string(elem)
+			case "PartNumber":
+				a.PartNumber = string(elem)
+			}
+			targetCharData = ""
+		case xml.EndElement:
+			if elem == se.End() {
+				return nil
+			}
+		}
+	}
+}
+
+type Build struct {
+	Type    BuildType
+	Version *Version
+}
+
+var _ xml.Unmarshaler = &Build{}
+
+func (b *Build) UnmarshalXML(dec *xml.Decoder, se xml.StartElement) error {
+	var targetCharData string
+	for {
+		token, err := dec.Token()
+		if err != nil {
+			return err
+		}
+
+		switch elem := token.(type) {
+		case xml.StartElement:
+			switch elem.Name.Local {
+			case "Version":
+				var version Version
+				if err := version.UnmarshalXML(dec, elem); err != nil {
+					return err
+				}
+				b.Version = &version
+			default:
+				targetCharData = elem.Name.Local
+			}
+		case xml.CharData:
+			switch targetCharData {
+			case "Type":
+				b.Type = BuildType(elem)
+			}
+			targetCharData = ""
+		case xml.EndElement:
+			if elem == se.End() {
+				return nil
+			}
+		}
+	}
+}
+
+type BuildType string
+
+const (
+	BuildTypeInternal BuildType = "Internal"
+	BuildTypeAlpha    BuildType = "Alpha"
+	BuildTypeBeta     BuildType = "Beta"
+	BuildTypeRelease  BuildType = "Release"
+)
+
+type Device struct {
+	Name      string   `xml:"Name"`
+	UnitId    uint32   `xml:"UnitId"`
+	ProductID uint16   `xml:"ProductID"`
+	Version   *Version `xml:"Version"`
+}
+
+var _ xml.Unmarshaler = &Device{}
+
+func (d *Device) UnmarshalXML(dec *xml.Decoder, se xml.StartElement) error {
+	var targetCharData string
+	for {
+		token, err := dec.Token()
+		if err != nil {
+			return err
+		}
+
+		switch elem := token.(type) {
+		case xml.StartElement:
+			switch elem.Name.Local {
+			case "Version":
+				var version Version
+				if err := version.UnmarshalXML(dec, elem); err != nil {
+					return err
+				}
+				d.Version = &version
+
+			default:
+				targetCharData = elem.Name.Local
+			}
+		case xml.CharData:
+			switch targetCharData {
+			case "Name":
+				d.Name = string(elem)
+			case "UnitId":
+				u, err := strconv.ParseUint(string(elem), 10, 32)
+				if err != nil {
+					return err
+				}
+				d.UnitId = uint32(u)
+			case "ProductID":
+				u, err := strconv.ParseUint(string(elem), 10, 16)
+				if err != nil {
+					return err
+				}
+				d.ProductID = uint16(u)
+			}
+			targetCharData = ""
+		case xml.EndElement:
+			if elem == se.End() {
+				return nil
+			}
+		}
+	}
+}
+
+type Version struct {
+	VersionMajor uint16 `xml:"VersionMajor"`
+	VersionMinor uint16 `xml:"VersionMinor"`
+	BuildMajor   uint16 `xml:"BuildMajor"`
+	BuildMinor   uint16 `xml:"BuildMinor"`
+}
+
+var _ xml.Unmarshaler = &Version{}
+
+func (v *Version) UnmarshalXML(dec *xml.Decoder, se xml.StartElement) error {
+	var targetCharData string
+	for {
+		token, err := dec.Token()
+		if err != nil {
+			return err
+		}
+
+		switch elem := token.(type) {
+		case xml.StartElement:
+			targetCharData = elem.Name.Local
+		case xml.CharData:
+			switch targetCharData {
+			case "VersionMajor":
+				u, err := strconv.ParseUint(string(elem), 10, 16)
+				if err != nil {
+					return err
+				}
+				v.VersionMajor = uint16(u)
+			case "VersionMinor":
+				u, err := strconv.ParseUint(string(elem), 10, 16)
+				if err != nil {
+					return err
+				}
+				v.VersionMinor = uint16(u)
+			case "BuildMajor":
+				u, err := strconv.ParseUint(string(elem), 10, 16)
+				if err != nil {
+					return err
+				}
+				v.BuildMajor = uint16(u)
+			case "BuildMinor":
+				u, err := strconv.ParseUint(string(elem), 10, 16)
+				if err != nil {
+					return err
+				}
+				v.BuildMinor = uint16(u)
+			}
+			targetCharData = ""
+		case xml.EndElement:
+			if elem == se.End() {
+				return nil
+			}
+		}
+	}
+}
diff --git a/src/wasm/activity-service/activity/tcx/schema/lap.go b/src/wasm/activity-service/activity/tcx/schema/lap.go
new file mode 100644
index 0000000..93b985f
--- /dev/null
+++ b/src/wasm/activity-service/activity/tcx/schema/lap.go
@@ -0,0 +1,136 @@
+package schema
+
+import (
+	"encoding/xml"
+	"strconv"
+	"time"
+
+	"github.com/muktihari/openactivity-fit/kit"
+)
+
+type ActivityLap struct {
+	StartTime           time.Time     `xml:"StartTime,attr"`
+	TotalTimeSeconds    float64       `xml:"TotalTimeSeconds"`
+	DistanceMeters      float64       `xml:"DistanceMeters"`
+	MaximumSpeed        *float64      `xml:"MaximumSpeed,omitempty"`
+	Calories            uint16        `xml:"Calories"`
+	AverageHeartRateBpm *uint8        `xml:"AverageHeartRateBpm"`
+	MaximumHeartRateBpm *uint8        `xml:"MaximumHeartRateBpm"`
+	Intensity           Intensity     `xml:"Intensity"`
+	Cadence             *uint8        `xml:"Cadence,omitempty"`
+	TriggerMethod       TriggerMethod `xml:"TriggerMethod"`
+	Tracks              []Track       `xml:"Track,omitempty"`
+	Notes               string        `xml:"Notes,omitempty"`
+}
+
+var _ xml.Unmarshaler = &ActivityLap{}
+
+func (a *ActivityLap) UnmarshalXML(dec *xml.Decoder, se xml.StartElement) error {
+	for i := range se.Attr {
+		attr := &se.Attr[i]
+
+		switch attr.Name.Local {
+		case "StartTime":
+			t, err := time.Parse(time.RFC3339, attr.Value)
+			if err != nil {
+				return err
+			}
+			a.StartTime = t
+		}
+	}
+
+	var targetCharData string
+	for {
+		token, err := dec.Token()
+		if err != nil {
+			return err
+		}
+
+		switch elem := token.(type) {
+		case xml.StartElement:
+			switch elem.Name.Local {
+			case "Track":
+				var track Track
+				if err := track.UnmarshalXML(dec, elem); err != nil {
+					return err
+				}
+				a.Tracks = append(a.Tracks, track)
+			default:
+				targetCharData = elem.Name.Local
+			}
+		case xml.CharData:
+			switch targetCharData {
+			case "TotalTimeSeconds":
+				f, err := strconv.ParseFloat(string(elem), 64)
+				if err != nil {
+					return err
+				}
+				a.TotalTimeSeconds = f
+			case "DistanceMeters":
+				f, err := strconv.ParseFloat(string(elem), 64)
+				if err != nil {
+					return err
+				}
+				a.DistanceMeters = f
+			case "MaximumSpeed":
+				f, err := strconv.ParseFloat(string(elem), 64)
+				if err != nil {
+					return err
+				}
+				a.MaximumSpeed = &f
+			case "Calories":
+				u, err := strconv.ParseUint(string(elem), 10, 16)
+				if err != nil {
+					return err
+				}
+				a.Calories = uint16(u)
+			case "AverageHeartRateBpm":
+				u, err := strconv.ParseUint(string(elem), 10, 8)
+				if err != nil {
+					return err
+				}
+				a.AverageHeartRateBpm = kit.Ptr(uint8(u))
+			case "MaximumHeartRateBpm":
+				u, err := strconv.ParseUint(string(elem), 10, 8)
+				if err != nil {
+					return err
+				}
+				a.MaximumHeartRateBpm = kit.Ptr(uint8(u))
+			case "Intensity":
+				a.Intensity = Intensity(elem)
+			case "Cadence":
+				u, err := strconv.ParseUint(string(elem), 10, 8)
+				if err != nil {
+					return err
+				}
+				a.Cadence = kit.Ptr(uint8(u))
+			case "TriggerMethod":
+				a.TriggerMethod = TriggerMethod(elem)
+			case "Notes":
+				a.Notes = string(elem)
+			}
+			targetCharData = ""
+		case xml.EndElement:
+			if elem == se.End() {
+				return nil
+			}
+		}
+	}
+}
+
+type Intensity string
+
+const (
+	IntensityActive  Intensity = "Active"
+	IntensityResting Intensity = "Resting"
+)
+
+type TriggerMethod string
+
+const (
+	TriggerMethodManual    TriggerMethod = "Manual"
+	TriggerMethodDistance  TriggerMethod = "Distance"
+	TriggerMethodLocation  TriggerMethod = "Location"
+	TriggerMethodTime      TriggerMethod = "Time"
+	TriggerMethodHeartRate TriggerMethod = "HeartRate"
+)
diff --git a/src/wasm/activity-service/activity/tcx/schema/tcx.go b/src/wasm/activity-service/activity/tcx/schema/tcx.go
new file mode 100644
index 0000000..0f305cd
--- /dev/null
+++ b/src/wasm/activity-service/activity/tcx/schema/tcx.go
@@ -0,0 +1,44 @@
+package schema
+
+import (
+	"encoding/xml"
+)
+
+// TCX simplified schema.
+type TCX struct {
+	Activities []ActivityList `xml:"Activities,omitempty"`
+	Author     *Application   `xml:"Author,omitempty"`
+}
+
+var _ xml.Unmarshaler = &TCX{}
+
+func (t *TCX) UnmarshalXML(dec *xml.Decoder, se xml.StartElement) error {
+	for {
+		token, err := dec.Token()
+		if err != nil {
+			return err
+		}
+
+		switch elem := token.(type) {
+		case xml.StartElement:
+			switch elem.Name.Local {
+			case "Activities":
+				var al ActivityList
+				if err := al.UnmarshalXML(dec, elem); err != nil {
+					return err
+				}
+				t.Activities = append(t.Activities, al)
+			case "Author":
+				var application Application
+				if err := application.UnmarshalXML(dec, elem); err != nil {
+					return err
+				}
+				t.Author = &application
+			}
+		case xml.EndElement:
+			if elem == se.End() {
+				return nil
+			}
+		}
+	}
+}
diff --git a/src/wasm/activity-service/activity/tcx/schema/track.go b/src/wasm/activity-service/activity/tcx/schema/track.go
new file mode 100644
index 0000000..3f50390
--- /dev/null
+++ b/src/wasm/activity-service/activity/tcx/schema/track.go
@@ -0,0 +1,170 @@
+package schema
+
+import (
+	"encoding/xml"
+	"fmt"
+	"strconv"
+	"time"
+
+	"github.com/muktihari/openactivity-fit/kit"
+)
+
+type Track struct {
+	Trackpoints []Trackpoint `xml:"Trackpoint,omitempty"`
+}
+
+var _ xml.Unmarshaler = &Track{}
+
+func (t *Track) UnmarshalXML(dec *xml.Decoder, se xml.StartElement) error {
+	for {
+		token, err := dec.Token()
+		if err != nil {
+			return err
+		}
+
+		switch elem := token.(type) {
+		case xml.StartElement:
+			switch elem.Name.Local {
+			case "Trackpoint":
+				var trackpoint Trackpoint
+				if err := trackpoint.UnmarshalXML(dec, elem); err != nil {
+					return err
+				}
+				t.Trackpoints = append(t.Trackpoints, trackpoint)
+			}
+		case xml.EndElement:
+			if elem == se.End() {
+				return nil
+			}
+		}
+	}
+}
+
+type Trackpoint struct {
+	Time           time.Time   `xml:"Time"`
+	Position       *Position   `xml:"Position,omitempty"`
+	AltitudeMeters *float64    `xml:"AltitudeMeters,omitempty"`
+	DistanceMeters *float64    `xml:"DistanceMeters,omitempty"`
+	HeartRateBpm   *uint8      `xml:"HeartRateBpm,omitempty"`
+	Cadence        *uint8      `xml:"Cadence,omitempty"`
+	SensorState    SensorState `xml:"SensorState,omitempty"`
+}
+
+var _ xml.Unmarshaler = &Trackpoint{}
+
+func (tp *Trackpoint) UnmarshalXML(dec *xml.Decoder, se xml.StartElement) error {
+	var targetCharData string
+	for {
+		token, err := dec.Token()
+		if err != nil {
+			return err
+		}
+
+		switch elem := token.(type) {
+		case xml.StartElement:
+			switch elem.Name.Local {
+			case "Position":
+				var position Position
+				if err := position.UnmarshalXML(dec, elem); err != nil {
+					return err
+				}
+				tp.Position = &position
+			case "Value":
+				if targetCharData == "HeartRateBpm" { // check prev value
+					targetCharData = "HeartRateBpmValue"
+				}
+			default:
+				targetCharData = elem.Name.Local
+			}
+		case xml.CharData:
+			switch targetCharData {
+			case "Time":
+				t, err := time.Parse(time.RFC3339, string(elem))
+				if err != nil {
+					return fmt.Errorf("parse Time %q: %w", elem, err)
+				}
+				tp.Time = t
+			case "AltitudeMeters":
+				f, err := strconv.ParseFloat(string(elem), 64)
+				if err != nil {
+					return fmt.Errorf("parse AltitudeMeters %q: %w", elem, err)
+				}
+				tp.AltitudeMeters = &f
+			case "DistanceMeters":
+				f, err := strconv.ParseFloat(string(elem), 64)
+				if err != nil {
+					return fmt.Errorf("parse DistanceMeters %q: %w", elem, err)
+				}
+				tp.DistanceMeters = &f
+			case "HeartRateBpmValue":
+				u, err := strconv.ParseUint(string(elem), 10, 8)
+				if err != nil {
+					return fmt.Errorf("parse HeartRateBpm %q: %w", elem, err)
+				}
+				tp.HeartRateBpm = kit.Ptr(uint8(u))
+			case "Cadence":
+				u, err := strconv.ParseUint(string(elem), 10, 8)
+				if err != nil {
+					return fmt.Errorf("parse Cadence %q: %w", elem, err)
+				}
+				tp.Cadence = kit.Ptr(uint8(u))
+			case "SensorState":
+				tp.SensorState = SensorState(elem)
+			}
+			targetCharData = ""
+		case xml.EndElement:
+			if elem == se.End() {
+				return nil
+			}
+		}
+	}
+}
+
+type Position struct {
+	LatitudeDegrees  float64 // -90.0 to 90.0
+	LongitudeDegrees float64 // -180.0 to 180.0
+}
+
+var _ xml.Unmarshaler = &Position{}
+
+func (p *Position) UnmarshalXML(dec *xml.Decoder, se xml.StartElement) error {
+	var targetCharData string
+	for {
+		token, err := dec.Token()
+		if err != nil {
+			return err
+		}
+
+		switch elem := token.(type) {
+		case xml.StartElement:
+			targetCharData = elem.Name.Local
+		case xml.CharData:
+			switch targetCharData {
+			case "LatitudeDegrees":
+				f, err := strconv.ParseFloat(string(elem), 64)
+				if err != nil {
+					return err
+				}
+				p.LatitudeDegrees = f
+			case "LongitudeDegrees":
+				f, err := strconv.ParseFloat(string(elem), 64)
+				if err != nil {
+					return err
+				}
+				p.LongitudeDegrees = f
+			}
+			targetCharData = ""
+		case xml.EndElement:
+			if elem == se.End() {
+				return nil
+			}
+		}
+	}
+}
+
+type SensorState string
+
+const (
+	SensorStatePresent SensorState = "Present"
+	SensorStateAbsent  SensorState = "Absent"
+)
diff --git a/src/wasm/activity-service/activity/tcx/service.go b/src/wasm/activity-service/activity/tcx/service.go
index f2da105..132d215 100644
--- a/src/wasm/activity-service/activity/tcx/service.go
+++ b/src/wasm/activity-service/activity/tcx/service.go
@@ -2,10 +2,12 @@ package tcx
 
 import (
 	"context"
+	"encoding/xml"
 	"fmt"
 	"io"
 
 	"github.com/muktihari/openactivity-fit/activity"
+	"github.com/muktihari/openactivity-fit/activity/tcx/schema"
 	"github.com/muktihari/openactivity-fit/preprocessor"
 )
 
@@ -20,5 +22,139 @@ func NewService(preproc *preprocessor.Preprocessor) activity.Service {
 }
 
 func (s *service) Decode(ctx context.Context, r io.Reader) ([]activity.Activity, error) {
-	return nil, fmt.Errorf("TODO: not yet implemented")
+	dec := xml.NewDecoder(r)
+
+	// NOTE: We manually define xml.Unmarshaler to void the reflection used
+	//       in default decoder, which is particularly slow expecially in WASM.
+
+	// Find start element
+	var start *xml.StartElement
+	if start == nil {
+		for {
+			tok, err := dec.Token()
+			if err != nil {
+				return nil, err
+			}
+			if t, ok := tok.(xml.StartElement); ok {
+				start = &t
+				break
+			}
+		}
+	}
+
+	if start == nil { // In case we got invalid xml, avoid panic.
+		return nil, fmt.Errorf("not a valid xml")
+	}
+
+	var tcx schema.TCX
+	if err := tcx.UnmarshalXML(dec, *start); err != nil {
+		return nil, err
+	}
+
+	act := new(activity.Activity)
+	if tcx.Author != nil {
+		act.Creator.Name = tcx.Author.Name
+	}
+	if len(tcx.Activities) > 0 && tcx.Activities[0].Activity != nil {
+		act.Creator.TimeCreated = tcx.Activities[0].Activity.ID
+	}
+
+	sessions := make([]*activity.Session, 0, len(tcx.Activities))
+
+	for i := range tcx.Activities {
+		a := tcx.Activities[i]
+		if a.Activity == nil {
+			continue
+		}
+
+		sport := activity.FormatTitle(a.Activity.Sport)
+
+		laps := make([]*activity.Lap, 0, len(a.Activity.Laps))
+
+		var recordCount int
+		for j := range a.Activity.Laps {
+			for k := range a.Activity.Laps[j].Tracks {
+				recordCount += len(a.Activity.Laps[j].Tracks[k].Trackpoints)
+			}
+		}
+
+		records := make([]*activity.Record, 0, recordCount)
+
+		for j := range a.Activity.Laps {
+			activityLap := a.Activity.Laps[j]
+
+			var lapRecordCount int
+			for k := range activityLap.Tracks {
+				lapRecordCount += len(activityLap.Tracks[k].Trackpoints)
+			}
+			lapRecords := make([]*activity.Record, 0, lapRecordCount)
+
+			var prevRec *activity.Record
+			for k := range activityLap.Tracks { // flattening tracks-trackpoints
+				for l := range activityLap.Tracks[k].Trackpoints {
+					tp := activityLap.Tracks[k].Trackpoints[l]
+
+					rec := NewRecord(&tp, prevRec)
+					prevRec = rec
+
+					lapRecords = append(lapRecords, rec)
+				}
+			}
+
+			if len(lapRecords) == 0 {
+				continue
+			}
+
+			// Preprocessing...
+			if activity.HasPace(sport) {
+				s.preprocessor.CalculatePace(sport, lapRecords)
+			}
+
+			s.preprocessor.SmoothingElev(lapRecords)
+			s.preprocessor.CalculateGrade(lapRecords)
+
+			records = append(records, lapRecords...)
+
+			lap := activity.NewLapFromRecords(lapRecords, sport)
+			lap.StartTime = activityLap.StartTime
+			lap.TotalDistance = activityLap.DistanceMeters
+			lap.TotalCalories = activityLap.Calories
+			lap.TotalElapsedTime = activityLap.TotalTimeSeconds
+
+			if activityLap.AverageHeartRateBpm != nil {
+				lap.AvgHeartRate = activityLap.AverageHeartRateBpm
+			}
+			if activityLap.MaximumHeartRateBpm != nil {
+				lap.MaxHeartRate = activityLap.MaximumHeartRateBpm
+			}
+
+			laps = append(laps, lap)
+		}
+
+		if len(laps) == 0 {
+			continue
+		}
+
+		session := activity.NewSessionFromLaps(laps, sport)
+		session.StartTime = a.Activity.ID
+
+		session.Laps = laps
+		session.Records = records
+
+		sessions = append(sessions, session)
+
+		if act.Creator.TimeCreated.IsZero() {
+			act.Creator.TimeCreated = session.StartTime
+			act.Creator.Name = a.Activity.Creator.Name
+			act.Creator.Product = &a.Activity.Creator.ProductID
+		}
+	}
+
+	if len(sessions) == 0 {
+		return nil, fmt.Errorf("tcx has no activity data")
+	}
+
+	act.Sessions = sessions
+
+	return []activity.Activity{*act}, nil
 }
diff --git a/src/wasm/activity-service/activity/util.go b/src/wasm/activity-service/activity/util.go
index 3a189d2..be744af 100644
--- a/src/wasm/activity-service/activity/util.go
+++ b/src/wasm/activity-service/activity/util.go
@@ -14,6 +14,8 @@ func IsConsideredMoving(sport string, speed *float64) bool {
 	}
 
 	switch sport {
+	case "Other", SportUnknown:
+		fallthrough // Since we don't know the specific sport, let's assume the slowest possible speed as our tolerance.
 	case "Hiking", "Walking", "Swimming": // slow moving exercise
 		return *speed > 0.1388 // = 0.5km/h
 	case "Running":
@@ -27,6 +29,10 @@ func HasPace(sport string) bool {
 	switch sport {
 	case "Hiking", "Walking", "Running", "Swimming":
 		return true
+	case "Other", SportUnknown:
+		// Since we don't know the specific sport, let's calculate the pace for now and allow the user to decide for themselves.
+		// It's better to provide additional information than to have none. (TBD)
+		return true
 	default:
 		return false
 	}
diff --git a/src/wasm/activity-service/preprocessor/preprocessor.go b/src/wasm/activity-service/preprocessor/preprocessor.go
index f25bbec..119532f 100644
--- a/src/wasm/activity-service/preprocessor/preprocessor.go
+++ b/src/wasm/activity-service/preprocessor/preprocessor.go
@@ -2,7 +2,6 @@ package preprocessor
 
 import (
 	"math"
-	"time"
 
 	"github.com/muktihari/openactivity-fit/activity"
 	"github.com/muktihari/openactivity-fit/kit"
@@ -120,8 +119,8 @@ func (p *Preprocessor) CalculatePace(sport string, records []*activity.Record) {
 		rec := records[i]
 		prev := records[i-1]
 
-		if rec.Distance == nil || rec.Timestamp == (time.Time{}) ||
-			prev.Distance == nil || prev.Timestamp == (time.Time{}) {
+		if rec.Distance == nil || rec.Timestamp.IsZero() ||
+			prev.Distance == nil || prev.Timestamp.IsZero() {
 			continue
 		}