shared/src/main/java/com/android/tools/analytics/AnalyticsSettings.kt - platform/tools/analytics-library - Git at Google

 /*
  * Copyright (C) 2018 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 com.android.tools.analytics

 import com.android.utils.DateProvider
 import com.android.utils.ILogger
 import com.google.common.annotations.VisibleForTesting
 import com.google.common.base.Charsets
 import com.google.common.hash.Hashing
 import com.google.common.io.Files
 import com.google.gson.GsonBuilder
 import com.google.gson.JsonParseException
 import com.google.gson.annotations.SerializedName
 import java.io.File
 import java.io.IOException
 import java.io.InputStreamReader
 import java.io.OutputStreamWriter
 import java.io.RandomAccessFile
 import java.math.BigInteger
 import java.net.URL
 import java.nio.channels.Channels
 import java.nio.channels.OverlappingFileLockException
 import java.nio.file.Paths
 import java.security.SecureRandom
 import java.time.Instant
 import java.time.LocalDate
 import java.time.ZoneOffset
 import java.time.temporal.ChronoUnit
 import java.util.Calendar
 import java.util.Date
 import java.util.GregorianCalendar
 import java.util.TimeZone
 import java.util.UUID
 import java.util.concurrent.ScheduledExecutorService
 import java.util.logging.Level
 import java.util.logging.Logger

 /**
  * Settings related to analytics reporting. These settings are stored in
  * ~/.android/analytics.settings as a json file.
  */
 object AnalyticsSettings {
   private val LOG = Logger.getLogger(AnalyticsSettings.javaClass.name)

   private const val DAYS_IN_LEAP_YEAR = 366
   private const val DAYS_IN_NON_LEAP_YEAR = 365
   private const val DAYS_TO_WAIT_FOR_REQUESTING_SENTIMENT_AGAIN = 7

   @JvmStatic
   var initialized = false
     private set

   @JvmStatic
   var exceptionThrown = false

   @JvmStatic
   val userId: String
     get() {
       return runIfAnalyticsSettingsUsable("") {
         instance?.userId ?: ""
       }
     }

   @JvmStatic
   var optedIn: Boolean
     get() {
       return runIfAnalyticsSettingsUsable(false) {
         instance?.optedIn ?: false
       }
     }

     set(value) {
       runIfAnalyticsSettingsUsable(Unit) {
         instance?.apply {
           optedIn = value
         }
       }
     }

   @JvmStatic
   private fun<T> runIfAnalyticsSettingsUsable(default: T, callback: () -> T): T {
     var throwable : Throwable? = null
     synchronized(gate) {
       if (exceptionThrown) {
         return default
       }
       ensureInitialized()
       try {
         return callback()
       } catch (t: Throwable) {
         exceptionThrown = true
         throwable = t
       }
     }
     if (throwable != null) {
       try {
         LOG.log(Level.SEVERE, throwable) { "AnalyticsSettings call failed" }
       } catch (ignored: Throwable) {
       }
     }
     return default
   }

   private fun ensureInitialized() {
     if (!initialized && java.lang.Boolean.getBoolean("idea.is.internal")) {
       // Android Studio Developers: If you hit this exception, you're trying to find out the status
       // of AnalyticsSettings before the system has been initialized. Please reach out the the owners
       // of this code to figure out how best to do these checks instead of getting null values.
       throw RuntimeException("call to AnalyticsSettings before initialization")
     }
   }

   @JvmStatic
   val debugDisablePublishing: Boolean
     get() {
       return runIfAnalyticsSettingsUsable(false) {
         instance?.debugDisablePublishing ?: false
       }
     }

   @JvmStatic
   var lastSentimentQuestionDate: Date?
     get() {
       return runIfAnalyticsSettingsUsable(null) {
         instance?.lastSentimentQuestionDate
       }
     }
     set(value) {
       runIfAnalyticsSettingsUsable(Unit) {
         instance?.lastSentimentQuestionDate = value
       }
     }

   @JvmStatic
   var lastSentimentAnswerDate: Date?
     get() {
       return runIfAnalyticsSettingsUsable(null) {
         instance?.lastSentimentAnswerDate
       }
     }
     set(value) {
       runIfAnalyticsSettingsUsable(Unit) {
         instance?.lastSentimentAnswerDate = value
       }
     }

   internal const val SALT_SKEW_NOT_INITIALIZED = -1

   @VisibleForTesting
   @JvmStatic
   var dateProvider: DateProvider = DateProvider.SYSTEM

   private val EPOCH = LocalDate.ofEpochDay(0)
   // the gate is used to ensure settings are accessed single-threaded
   private val gate = Any()

   @JvmStatic
   private var instance: AnalyticsSettingsData? = null

   /**
    * Gets the current salt skew, this is used by [.getSalt] to update the salt every 28
    * days with a consistent window. This window size allows 4 week and 1 week analyses.
    */
   @VisibleForTesting
   @JvmStatic
   fun currentSaltSkew(): Int {
     val now = LocalDate.from(
       Instant.ofEpochMilli(dateProvider.now().time).atZone(ZoneOffset.UTC))
     // Unix epoch was on a Thursday, but we want Monday to be the day the salt is refreshed.
     val days = ChronoUnit.DAYS.between(EPOCH, now) + 3
     return (days / 28).toInt()
   }

   /**
    * Loads an existing settings file from disk, or creates a new valid settings object if none
    * exists. In case of the latter, will try to load uid.txt for maintaining the same uid with
    * previous metrics reporting.
    *
    * @throws IOException if there are any issues reading the settings file.
    */
   @VisibleForTesting
   @Throws(IOException::class)
   @JvmStatic
   private fun loadSettingsData(logger: ILogger): AnalyticsSettingsData {
     val file = settingsFile
     if (!file.exists()) {
       return createNewAnalyticsSettingsData()
     }
     val channel = RandomAccessFile(file, "rw").channel
     try {
       val settings: AnalyticsSettingsData? = channel.tryLock().use {
         val inputStream = Channels.newInputStream(channel)
         val gson = GsonBuilder().create()
         gson.fromJson(InputStreamReader(inputStream), AnalyticsSettingsData::class.java)
       }
       if (settings == null || !isValid(settings)) {
         return createNewAnalyticsSettingsData()
       }
       return settings
     }
     catch (e: OverlappingFileLockException) {
       logger.warning("Unable to lock settings file %s: %s", file.toString(), e)
     }
     catch (e: JsonParseException) {
       logger.warning("Unable to parse settings file %s: %s", file.toString(), e)
     }
     catch (e: IllegalStateException) {
       logger.warning("Unable to parse settings file %s: %s", file.toString(), e)
     }
     var newSettings = AnalyticsSettingsData()
     newSettings.userId = UUID.randomUUID().toString()
     return newSettings
   }

   /**
    * Creates a new settings object and writes it to disk. Will try to load uid.txt for maintaining
    * the same uid with previous metrics reporting.
    *
    * @throws IOException if there are any issues writing the settings file.
    */
   @VisibleForTesting
   @JvmStatic
   @Throws(IOException::class)
   private fun createNewAnalyticsSettingsData(): AnalyticsSettingsData {
     val settings = AnalyticsSettingsData()

     val uidFile = Paths.get(AnalyticsPaths.getAndEnsureAndroidSettingsHome(), "uid.txt").toFile()
     if (uidFile.exists()) {
       try {
         val uid = Files.readFirstLine(uidFile, Charsets.UTF_8)
         settings.userId = uid
       }
       catch (e: IOException) {
         // Ignore and set new UID.
       }

     }
     if (settings.userId == null) {
       settings.userId = UUID.randomUUID().toString()
     }
     settings.saveSettings()
     return settings
   }

   @JvmStatic
   var googlePlayDateProvider: WebServerDateProvider? = null

   /**
    * Get or creates an instance of the settings. Uses the following strategies in order:
    *
    *
    *  * Use existing instance
    *  * Load existing 'analytics.settings' file from disk
    *  * Create new 'analytics.settings' file
    *  * Create instance without persistence
    *
    *
    * Any issues reading/writing the config file will be logged to the logger.
    */
   @JvmStatic
   @JvmOverloads
   fun initialize(logger: ILogger, scheduler: ScheduledExecutorService? = null) {
     synchronized(gate) {
       try {
         if (instance != null) {
           return
         }
         initialized = true
         instance = loadSettingsData(logger)
       } catch (e : IOException) {
         // null out metrics in case of failure to load.
         initialized = true
         instance = AnalyticsSettingsData()
         logger.warning("Unable to initialize metrics, ensure %s is writable, details: %s",
                        AnalyticsPaths.getAndEnsureAndroidSettingsHome(), e.message)
       }
     }
     scheduler?.submit {
       try {
         val gp = WebServerDateProvider(URL("https://play.google.com/"))
         dateProvider = gp
         googlePlayDateProvider = gp
       }
       catch (_: IOException) {
         logger.warning("Unable to get current time from Google's servers, using local system time instead.")
       }
     }
   }

   /**
    * initializes or updates AnalyticsSettings into a disabled state.
    */
   @JvmStatic
   fun disable() {
     synchronized(gate) {
       initialized = true
       instance = AnalyticsSettingsData()
       dateProvider = DateProvider.SYSTEM
       googlePlayDateProvider = null
     }
   }

   /**
    * Allows test to set a custom version of the AnalyticsSettings to test different setting
    * states.
    */
   @VisibleForTesting
   @JvmStatic
   fun setInstanceForTest(settings: AnalyticsSettingsData?) {
     synchronized(gate) {
       instance = settings
       initialized = instance != null
       exceptionThrown = false
     }
   }

   /**
    * Helper to get the file to read/write settings from based on the configured android settings
    * home.
    */
   internal val settingsFile: File
     get() = Paths.get(AnalyticsPaths.getAndEnsureAndroidSettingsHome(), "analytics.settings").toFile()


   /**
    * Gets a binary blob to ensure per user anonymization. Gets automatically rotated every 28
    * days. Primarily used by [Anonymizer].
    */
   val salt: ByteArray
     @Throws(IOException::class)
     get() = synchronized(AnalyticsSettings.gate) {
       var data: AnalyticsSettingsData = instance ?: return byteArrayOf()
       // Starting with Android Studio 3.5 we switch to 532 day rotation, this logic is to coincide with that change
       // starting with the rotation on 2018/11/26. 28*19 = 532 days and -11 is to offset with the 28 day rotation cycle starting on
       // 2018/11/26.
       var dataSkew532 : Int = ( data.saltSkew - 11 )/ 19
       var currentSaltSkew = com.android.tools.analytics.AnalyticsSettings.currentSaltSkew()
       val currentSaltSkew532: Int = (currentSaltSkew - 11) / 19
       if (dataSkew532 != currentSaltSkew532) {
         data.saltSkew = currentSaltSkew
         val random = SecureRandom()
         val blob = ByteArray(24)
         random.nextBytes(blob)
         data.saltValue = BigInteger(blob)
         saveSettings()
       }
       return data.saltValue.toByteArrayOfLength24()
     }

   /**
    * Writes this settings object to disk.
    * @throws IOException if there are any issues writing the settings file.
    */
   @JvmStatic
   @Throws(IOException::class)
   fun saveSettings() {
     runIfAnalyticsSettingsUsable(Unit) {
       instance?.saveSettings()
     }
   }

   /** Checks if the AnalyticsSettings object is in a valid state.  */
   internal fun isValid(settings: AnalyticsSettingsData): Boolean {
     return settings.userId != null && (settings.saltSkew == AnalyticsSettings.SALT_SKEW_NOT_INITIALIZED || settings.saltValue != null)
   }

   fun shouldRequestUserSentiment(): Boolean {
     if (!optedIn) {
       return false
     }

     val lastSentimentAnswerDate = AnalyticsSettings.lastSentimentAnswerDate
     val lastSentimentQuestionDate = AnalyticsSettings.lastSentimentQuestionDate
     val now = dateProvider.now()

     var daysInYear = DAYS_IN_NON_LEAP_YEAR
     if (GregorianCalendar().isLeapYear(now.year + 1900)) {
       daysInYear = DAYS_IN_LEAP_YEAR
     }

     if (lastSentimentAnswerDate != null) {
       val calendar = Calendar.getInstance()
       calendar.time = now
       calendar.add(Calendar.DATE, -daysInYear)
       val lastYear = calendar.time
       if (lastSentimentAnswerDate.after(lastYear)) {
         return false
       }
     }

     // If we should ask the question based on dates, and asked but not answered then we should always prompt, even if this is
     // not the magic date for that user.
     if (lastSentimentQuestionDate != null) {
       val calendar = Calendar.getInstance()
       calendar.time = now
       calendar.add(Calendar.DATE, -DAYS_TO_WAIT_FOR_REQUESTING_SENTIMENT_AGAIN)
       val startOfWaitForRequest = calendar.time
       return !lastSentimentQuestionDate.after(startOfWaitForRequest)
     }

     val startOfYear = GregorianCalendar(now.year + 1900 ,0, 1)
     startOfYear.timeZone = TimeZone.getTimeZone(ZoneOffset.UTC)

     // Otherwise, only request on the magic date for the user, to spread user sentiment data throughout the year.
     var daysSinceJanFirst = ChronoUnit.DAYS.between(startOfYear.toInstant(), now.toInstant())
     var offset = Math.abs(Hashing.farmHashFingerprint64().hashString(AnalyticsSettings.userId, Charsets.UTF_8).asLong()) % daysInYear
     return daysSinceJanFirst == offset
   }
 }

 class AnalyticsSettingsData {
   fun saveSettings() {
     val file = AnalyticsSettings.settingsFile
     var dir = file.parentFile
     if (!dir.exists()) {
       dir.mkdirs()
     }
     try {
       RandomAccessFile(file, "rw").use { settingsFile ->
         settingsFile.channel.use { channel ->
           channel.tryLock().use { lock ->
             if (lock == null) {
               throw IOException("Unable to lock settings file " + file.toString())
             }
             val gson = GsonBuilder().create()
             val readStream = InputStreamReader(Channels.newInputStream(channel))
             val existingData = gson.fromJson(readStream, AnalyticsSettingsData::class.java)
             if (existingData?.saltSkew == saltSkew) {
               // The salt is apparently updated by some other process. In this case we read that on the disk rather than using our own in
               // order to make sure all processes use the same salt.
               saltValue = existingData.saltValue
             }
             channel.truncate(0)
             val outputStream = Channels.newOutputStream(channel)
             val writer = OutputStreamWriter(outputStream)
             gson.toJson(this, writer)
             writer.flush()
             outputStream.flush()
           }
         }
       }
     }
     catch (e: OverlappingFileLockException) {
       throw IOException("Unable to lock settings file " + file.toString(), e)
     }
   }

   /**
    * User id used for reporting analytics. This id is pseudo-anonymous.
    */
   @field:SerializedName("userId")
   var userId: String? = null

   @field:SerializedName("hasOptedIn")
   var optedIn: Boolean = false

   @field:SerializedName("debugDisablePublishing")
   val debugDisablePublishing: Boolean = false

   @field:SerializedName("saltValue")
   var saltValue = BigInteger.valueOf(0L)

   @field:SerializedName("saltSkew")
   var saltSkew = AnalyticsSettings.SALT_SKEW_NOT_INITIALIZED

   @field:SerializedName("lastSentimentQuestionDate")
   var lastSentimentQuestionDate : Date? = null

   @field:SerializedName("lastSentimentAnswerDate")
   var lastSentimentAnswerDate : Date? = null
 }

 fun BigInteger.toByteArrayOfLength24(): ByteArray {
   val blob = toByteArray()
   var fullBlob = blob
   if (blob.size < 24) {
     fullBlob = ByteArray(24)
     System.arraycopy(blob, 0, fullBlob, 0, blob.size)
   }
   return fullBlob
 }
	/*
	* Copyright (C) 2018 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 com.android.tools.analytics

	import com.android.utils.DateProvider
	import com.android.utils.ILogger
	import com.google.common.annotations.VisibleForTesting
	import com.google.common.base.Charsets
	import com.google.common.hash.Hashing
	import com.google.common.io.Files
	import com.google.gson.GsonBuilder
	import com.google.gson.JsonParseException
	import com.google.gson.annotations.SerializedName
	import java.io.File
	import java.io.IOException
	import java.io.InputStreamReader
	import java.io.OutputStreamWriter
	import java.io.RandomAccessFile
	import java.math.BigInteger
	import java.net.URL
	import java.nio.channels.Channels
	import java.nio.channels.OverlappingFileLockException
	import java.nio.file.Paths
	import java.security.SecureRandom
	import java.time.Instant
	import java.time.LocalDate
	import java.time.ZoneOffset
	import java.time.temporal.ChronoUnit
	import java.util.Calendar
	import java.util.Date
	import java.util.GregorianCalendar
	import java.util.TimeZone
	import java.util.UUID
	import java.util.concurrent.ScheduledExecutorService
	import java.util.logging.Level
	import java.util.logging.Logger

	/**
	* Settings related to analytics reporting. These settings are stored in
	* ~/.android/analytics.settings as a json file.
	*/
	object AnalyticsSettings {
	private val LOG = Logger.getLogger(AnalyticsSettings.javaClass.name)

	private const val DAYS_IN_LEAP_YEAR = 366
	private const val DAYS_IN_NON_LEAP_YEAR = 365
	private const val DAYS_TO_WAIT_FOR_REQUESTING_SENTIMENT_AGAIN = 7

	@JvmStatic
	var initialized = false
	private set

	@JvmStatic
	var exceptionThrown = false

	@JvmStatic
	val userId: String
	get() {
	return runIfAnalyticsSettingsUsable("") {
	instance?.userId ?: ""
	}
	}

	@JvmStatic
	var optedIn: Boolean
	get() {
	return runIfAnalyticsSettingsUsable(false) {
	instance?.optedIn ?: false
	}
	}

	set(value) {
	runIfAnalyticsSettingsUsable(Unit) {
	instance?.apply {
	optedIn = value
	}
	}
	}

	@JvmStatic
	private fun<T> runIfAnalyticsSettingsUsable(default: T, callback: () -> T): T {
	var throwable : Throwable? = null
	synchronized(gate) {
	if (exceptionThrown) {
	return default
	}
	ensureInitialized()
	try {
	return callback()
	} catch (t: Throwable) {
	exceptionThrown = true
	throwable = t
	}
	}
	if (throwable != null) {
	try {
	LOG.log(Level.SEVERE, throwable) { "AnalyticsSettings call failed" }
	} catch (ignored: Throwable) {
	}
	}
	return default
	}

	private fun ensureInitialized() {
	if (!initialized && java.lang.Boolean.getBoolean("idea.is.internal")) {
	// Android Studio Developers: If you hit this exception, you're trying to find out the status
	// of AnalyticsSettings before the system has been initialized. Please reach out the the owners
	// of this code to figure out how best to do these checks instead of getting null values.
	throw RuntimeException("call to AnalyticsSettings before initialization")
	}
	}

	@JvmStatic
	val debugDisablePublishing: Boolean
	get() {
	return runIfAnalyticsSettingsUsable(false) {
	instance?.debugDisablePublishing ?: false
	}
	}

	@JvmStatic
	var lastSentimentQuestionDate: Date?
	get() {
	return runIfAnalyticsSettingsUsable(null) {
	instance?.lastSentimentQuestionDate
	}
	}
	set(value) {
	runIfAnalyticsSettingsUsable(Unit) {
	instance?.lastSentimentQuestionDate = value
	}
	}

	@JvmStatic
	var lastSentimentAnswerDate: Date?
	get() {
	return runIfAnalyticsSettingsUsable(null) {
	instance?.lastSentimentAnswerDate
	}
	}
	set(value) {
	runIfAnalyticsSettingsUsable(Unit) {
	instance?.lastSentimentAnswerDate = value
	}
	}

	internal const val SALT_SKEW_NOT_INITIALIZED = -1

	@VisibleForTesting
	@JvmStatic
	var dateProvider: DateProvider = DateProvider.SYSTEM

	private val EPOCH = LocalDate.ofEpochDay(0)
	// the gate is used to ensure settings are accessed single-threaded
	private val gate = Any()

	@JvmStatic
	private var instance: AnalyticsSettingsData? = null

	/**
	* Gets the current salt skew, this is used by [.getSalt] to update the salt every 28
	* days with a consistent window. This window size allows 4 week and 1 week analyses.
	*/
	@VisibleForTesting
	@JvmStatic
	fun currentSaltSkew(): Int {
	val now = LocalDate.from(
	Instant.ofEpochMilli(dateProvider.now().time).atZone(ZoneOffset.UTC))
	// Unix epoch was on a Thursday, but we want Monday to be the day the salt is refreshed.
	val days = ChronoUnit.DAYS.between(EPOCH, now) + 3
	return (days / 28).toInt()
	}

	/**
	* Loads an existing settings file from disk, or creates a new valid settings object if none
	* exists. In case of the latter, will try to load uid.txt for maintaining the same uid with
	* previous metrics reporting.
	*
	* @throws IOException if there are any issues reading the settings file.
	*/
	@VisibleForTesting
	@Throws(IOException::class)
	@JvmStatic
	private fun loadSettingsData(logger: ILogger): AnalyticsSettingsData {
	val file = settingsFile
	if (!file.exists()) {
	return createNewAnalyticsSettingsData()
	}
	val channel = RandomAccessFile(file, "rw").channel
	try {
	val settings: AnalyticsSettingsData? = channel.tryLock().use {
	val inputStream = Channels.newInputStream(channel)
	val gson = GsonBuilder().create()
	gson.fromJson(InputStreamReader(inputStream), AnalyticsSettingsData::class.java)
	}
	if (settings == null \|\| !isValid(settings)) {
	return createNewAnalyticsSettingsData()
	}
	return settings
	}
	catch (e: OverlappingFileLockException) {
	logger.warning("Unable to lock settings file %s: %s", file.toString(), e)
	}
	catch (e: JsonParseException) {
	logger.warning("Unable to parse settings file %s: %s", file.toString(), e)
	}
	catch (e: IllegalStateException) {
	logger.warning("Unable to parse settings file %s: %s", file.toString(), e)
	}
	var newSettings = AnalyticsSettingsData()
	newSettings.userId = UUID.randomUUID().toString()
	return newSettings
	}

	/**
	* Creates a new settings object and writes it to disk. Will try to load uid.txt for maintaining
	* the same uid with previous metrics reporting.
	*
	* @throws IOException if there are any issues writing the settings file.
	*/
	@VisibleForTesting
	@JvmStatic
	@Throws(IOException::class)
	private fun createNewAnalyticsSettingsData(): AnalyticsSettingsData {
	val settings = AnalyticsSettingsData()

	val uidFile = Paths.get(AnalyticsPaths.getAndEnsureAndroidSettingsHome(), "uid.txt").toFile()
	if (uidFile.exists()) {
	try {
	val uid = Files.readFirstLine(uidFile, Charsets.UTF_8)
	settings.userId = uid
	}
	catch (e: IOException) {
	// Ignore and set new UID.
	}

	}
	if (settings.userId == null) {
	settings.userId = UUID.randomUUID().toString()
	}
	settings.saveSettings()
	return settings
	}

	@JvmStatic
	var googlePlayDateProvider: WebServerDateProvider? = null

	/**
	* Get or creates an instance of the settings. Uses the following strategies in order:
	*
	*
	* * Use existing instance
	* * Load existing 'analytics.settings' file from disk
	* * Create new 'analytics.settings' file
	* * Create instance without persistence
	*
	*
	* Any issues reading/writing the config file will be logged to the logger.
	*/
	@JvmStatic
	@JvmOverloads
	fun initialize(logger: ILogger, scheduler: ScheduledExecutorService? = null) {
	synchronized(gate) {
	try {
	if (instance != null) {
	return
	}
	initialized = true
	instance = loadSettingsData(logger)
	} catch (e : IOException) {
	// null out metrics in case of failure to load.
	initialized = true
	instance = AnalyticsSettingsData()
	logger.warning("Unable to initialize metrics, ensure %s is writable, details: %s",
	AnalyticsPaths.getAndEnsureAndroidSettingsHome(), e.message)
	}
	}
	scheduler?.submit {
	try {
	val gp = WebServerDateProvider(URL("https://play.google.com/"))
	dateProvider = gp
	googlePlayDateProvider = gp
	}
	catch (_: IOException) {
	logger.warning("Unable to get current time from Google's servers, using local system time instead.")
	}
	}
	}

	/**
	* initializes or updates AnalyticsSettings into a disabled state.
	*/
	@JvmStatic
	fun disable() {
	synchronized(gate) {
	initialized = true
	instance = AnalyticsSettingsData()
	dateProvider = DateProvider.SYSTEM
	googlePlayDateProvider = null
	}
	}

	/**
	* Allows test to set a custom version of the AnalyticsSettings to test different setting
	* states.
	*/
	@VisibleForTesting
	@JvmStatic
	fun setInstanceForTest(settings: AnalyticsSettingsData?) {
	synchronized(gate) {
	instance = settings
	initialized = instance != null
	exceptionThrown = false
	}
	}

	/**
	* Helper to get the file to read/write settings from based on the configured android settings
	* home.
	*/
	internal val settingsFile: File
	get() = Paths.get(AnalyticsPaths.getAndEnsureAndroidSettingsHome(), "analytics.settings").toFile()


	/**
	* Gets a binary blob to ensure per user anonymization. Gets automatically rotated every 28
	* days. Primarily used by [Anonymizer].
	*/
	val salt: ByteArray
	@Throws(IOException::class)
	get() = synchronized(AnalyticsSettings.gate) {
	var data: AnalyticsSettingsData = instance ?: return byteArrayOf()
	// Starting with Android Studio 3.5 we switch to 532 day rotation, this logic is to coincide with that change
	// starting with the rotation on 2018/11/26. 28*19 = 532 days and -11 is to offset with the 28 day rotation cycle starting on
	// 2018/11/26.
	var dataSkew532 : Int = ( data.saltSkew - 11 )/ 19
	var currentSaltSkew = com.android.tools.analytics.AnalyticsSettings.currentSaltSkew()
	val currentSaltSkew532: Int = (currentSaltSkew - 11) / 19
	if (dataSkew532 != currentSaltSkew532) {
	data.saltSkew = currentSaltSkew
	val random = SecureRandom()
	val blob = ByteArray(24)
	random.nextBytes(blob)
	data.saltValue = BigInteger(blob)
	saveSettings()
	}
	return data.saltValue.toByteArrayOfLength24()
	}

	/**
	* Writes this settings object to disk.
	* @throws IOException if there are any issues writing the settings file.
	*/
	@JvmStatic
	@Throws(IOException::class)
	fun saveSettings() {
	runIfAnalyticsSettingsUsable(Unit) {
	instance?.saveSettings()
	}
	}

	/** Checks if the AnalyticsSettings object is in a valid state. */
	internal fun isValid(settings: AnalyticsSettingsData): Boolean {
	return settings.userId != null && (settings.saltSkew == AnalyticsSettings.SALT_SKEW_NOT_INITIALIZED \|\| settings.saltValue != null)
	}

	fun shouldRequestUserSentiment(): Boolean {
	if (!optedIn) {
	return false
	}

	val lastSentimentAnswerDate = AnalyticsSettings.lastSentimentAnswerDate
	val lastSentimentQuestionDate = AnalyticsSettings.lastSentimentQuestionDate
	val now = dateProvider.now()

	var daysInYear = DAYS_IN_NON_LEAP_YEAR
	if (GregorianCalendar().isLeapYear(now.year + 1900)) {
	daysInYear = DAYS_IN_LEAP_YEAR
	}

	if (lastSentimentAnswerDate != null) {
	val calendar = Calendar.getInstance()
	calendar.time = now
	calendar.add(Calendar.DATE, -daysInYear)
	val lastYear = calendar.time
	if (lastSentimentAnswerDate.after(lastYear)) {
	return false
	}
	}

	// If we should ask the question based on dates, and asked but not answered then we should always prompt, even if this is
	// not the magic date for that user.
	if (lastSentimentQuestionDate != null) {
	val calendar = Calendar.getInstance()
	calendar.time = now
	calendar.add(Calendar.DATE, -DAYS_TO_WAIT_FOR_REQUESTING_SENTIMENT_AGAIN)
	val startOfWaitForRequest = calendar.time
	return !lastSentimentQuestionDate.after(startOfWaitForRequest)
	}

	val startOfYear = GregorianCalendar(now.year + 1900 ,0, 1)
	startOfYear.timeZone = TimeZone.getTimeZone(ZoneOffset.UTC)

	// Otherwise, only request on the magic date for the user, to spread user sentiment data throughout the year.
	var daysSinceJanFirst = ChronoUnit.DAYS.between(startOfYear.toInstant(), now.toInstant())
	var offset = Math.abs(Hashing.farmHashFingerprint64().hashString(AnalyticsSettings.userId, Charsets.UTF_8).asLong()) % daysInYear
	return daysSinceJanFirst == offset
	}
	}

	class AnalyticsSettingsData {
	fun saveSettings() {
	val file = AnalyticsSettings.settingsFile
	var dir = file.parentFile
	if (!dir.exists()) {
	dir.mkdirs()
	}
	try {
	RandomAccessFile(file, "rw").use { settingsFile ->
	settingsFile.channel.use { channel ->
	channel.tryLock().use { lock ->
	if (lock == null) {
	throw IOException("Unable to lock settings file " + file.toString())
	}
	val gson = GsonBuilder().create()
	val readStream = InputStreamReader(Channels.newInputStream(channel))
	val existingData = gson.fromJson(readStream, AnalyticsSettingsData::class.java)
	if (existingData?.saltSkew == saltSkew) {
	// The salt is apparently updated by some other process. In this case we read that on the disk rather than using our own in
	// order to make sure all processes use the same salt.
	saltValue = existingData.saltValue
	}
	channel.truncate(0)
	val outputStream = Channels.newOutputStream(channel)
	val writer = OutputStreamWriter(outputStream)
	gson.toJson(this, writer)
	writer.flush()
	outputStream.flush()
	}
	}
	}
	}
	catch (e: OverlappingFileLockException) {
	throw IOException("Unable to lock settings file " + file.toString(), e)
	}
	}

	/**
	* User id used for reporting analytics. This id is pseudo-anonymous.
	*/
	@field:SerializedName("userId")
	var userId: String? = null

	@field:SerializedName("hasOptedIn")
	var optedIn: Boolean = false

	@field:SerializedName("debugDisablePublishing")
	val debugDisablePublishing: Boolean = false

	@field:SerializedName("saltValue")
	var saltValue = BigInteger.valueOf(0L)

	@field:SerializedName("saltSkew")
	var saltSkew = AnalyticsSettings.SALT_SKEW_NOT_INITIALIZED

	@field:SerializedName("lastSentimentQuestionDate")
	var lastSentimentQuestionDate : Date? = null

	@field:SerializedName("lastSentimentAnswerDate")
	var lastSentimentAnswerDate : Date? = null
	}

	fun BigInteger.toByteArrayOfLength24(): ByteArray {
	val blob = toByteArray()
	var fullBlob = blob
	if (blob.size < 24) {
	fullBlob = ByteArray(24)
	System.arraycopy(blob, 0, fullBlob, 0, blob.size)
	}
	return fullBlob
	}