A brief analysis of the SexualActivityRecord class in the Android development documentation

I was just surfing the Internet and was shocked to see a hot topic on Reddit. I thought Android had made big news and instantly thought of a title: Google's Android system is doing something incredible - monitoring the frequency of "Clap for Love".

https://www.reddit.com/r/programming/comments/16iy537/android_has_a_separate_class_and_documentation_to/

Taking another look, it turns out that the Android development documentation provides a "SexualActivityRecord" class for recording the frequency of sexual life.

https://developer.android.com/reference/androidx/health/connect/client/records/SexualActivityRecord

Let's take a look at how Google engineers wrote this class.

You can see that this class has a total of 3 constants, representing whether Sex takes protective measures:

• 1: Security protection has been done
• 0: Unknown
• 2: No security protection

The main public methods are getProtectionUsed(), getTime(), and getZoneOffset().

The first two are understandable, which are to get the protection measures and the time when they occurred, but what does the last ZoneOffset mean? Could you please explain it to me?

As we all know, Kotlin has long been an officially supported development language for Android, so the code for this class is also written in Kotlin, with less than 100 lines in total:

SexualActivityRecord.kt

 /* * Copyright (C) 2022 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package androidx.health.connect.client.records import androidx.annotation.IntDef import androidx.annotation.RestrictTo import androidx.health.connect.client.records.metadata.Metadata import java.time.Instant import java.time.ZoneOffset /** * Captures an occurrence of sexual activity. Each record is a single occurrence. ProtectionUsed * field is optional. */ public class SexualActivityRecord( override val time: Instant, override val zoneOffset: ZoneOffset?, /** * Whether protection was used during sexual activity. Optional field, null if unknown. Allowed * values: [Protection]. * * @see Protection */ @property:Protections public val protectionUsed: Int = PROTECTION_USED_UNKNOWN, override val metadata: Metadata = Metadata.EMPTY, ) : InstantaneousRecord { override fun equals(other: Any?): Boolean { if (this === other) return true if (other !is SexualActivityRecord) return false if (protectionUsed != other.protectionUsed) return false if (time != other.time) return false if (zoneOffset != other.zoneOffset) return false if (metadata != other.metadata) return false return true } override fun hashCode(): Int { var result = protectionUsed result = 31 * result + time.hashCode() result = 31 * result + (zoneOffset?.hashCode() ?: 0) result = 31 * result + metadata.hashCode() return result } companion object { const val PROTECTION_USED_UNKNOWN = 0 const val PROTECTION_USED_PROTECTED = 1 const val PROTECTION_USED_UNPROTECTED = 2 /** Internal mappings useful for interoperability between integers and strings. */ @RestrictTo(RestrictTo.Scope.LIBRARY) @JvmField val PROTECTION_USED_STRING_TO_INT_MAP: Map<String, Int> = mapOf( Protection.PROTECTED to PROTECTION_USED_PROTECTED, Protection.UNPROTECTED to PROTECTION_USED_UNPROTECTED, ) @RestrictTo(RestrictTo.Scope.LIBRARY) @JvmField val PROTECTION_USED_INT_TO_STRING_MAP = PROTECTION_USED_STRING_TO_INT_MAP.reverse() } /** Whether protection was used during sexual activity. */ internal object Protection { const val PROTECTED = "protected" const val UNPROTECTED = "unprotected" } /** * Whether protection was used during sexual activity. */ @Retention(AnnotationRetention.SOURCE) @IntDef( value = [ PROTECTION_USED_PROTECTED, PROTECTION_USED_UNPROTECTED, ] ) @RestrictTo(RestrictTo.Scope.LIBRARY) annotation class Protections }

Well, this sharing ends here, and everyone is welcome to express their opinions. If you were responsible for writing this class, how would you implement it?