Convert TracingPowerManager to Kotlin

package com.fsck.k9.power;

package com.fsck.k9.power

import android.annotation.SuppressLint

import android.content.Context

import android.os.SystemClock

import com.fsck.k9.mail.power.PowerManager

import com.fsck.k9.mail.power.WakeLock

import java.util.concurrent.atomic.AtomicInteger

import timber.log.Timber

import android.os.PowerManager as SystemPowerManager

import android.os.PowerManager.WakeLock as SystemWakeLock

import java.util.concurrent.atomic.AtomicInteger;

class TracingPowerManager private constructor(context: Context) : PowerManager {

    private val powerManager = context.getSystemService(Context.POWER_SERVICE) as SystemPowerManager

import android.content.Context;

import android.os.PowerManager;

import android.os.PowerManager.WakeLock;

import android.os.SystemClock;

import com.fsck.k9.mail.K9MailLib;

import org.jetbrains.annotations.NotNull;

import timber.log.Timber;

public class TracingPowerManager implements com.fsck.k9.mail.power.PowerManager {

    public static AtomicInteger wakeLockId = new AtomicInteger(0);

    PowerManager pm = null;

    private static TracingPowerManager tracingPowerManager;

    public static synchronized TracingPowerManager getPowerManager(Context context) {

        Context appContext = context.getApplicationContext();

        if (tracingPowerManager == null) {

            if (K9MailLib.isDebug()) {

                Timber.v("Creating TracingPowerManager");

    override fun newWakeLock(tag: String): WakeLock {

        return TracingWakeLock(SystemPowerManager.PARTIAL_WAKE_LOCK, tag)

    }

            tracingPowerManager = new TracingPowerManager(appContext);

        }

        return tracingPowerManager;

    fun newWakeLock(flags: Int, tag: String?): TracingWakeLock {

        return TracingWakeLock(flags, tag)

    }

    inner class TracingWakeLock(flags: Int, val tag: String?) : WakeLock {

        private val wakeLock: SystemWakeLock = powerManager.newWakeLock(flags, tag)

        private val id = wakeLockId.getAndIncrement()

    private TracingPowerManager(Context context) {

        pm = (PowerManager) context.getSystemService(Context.POWER_SERVICE);

        @Volatile

        private var startTime: Long? = null

    }

        @Volatile

        private var timeout: Long? = null

    @NotNull

    @Override

    public com.fsck.k9.mail.power.WakeLock newWakeLock(@NotNull String tag) {

        return new TracingWakeLock(PowerManager.PARTIAL_WAKE_LOCK, tag);

        init {

            Timber.v("TracingWakeLock for tag %s / id %d: Create", tag, id)

        }

    public TracingWakeLock newWakeLock(int flags, String tag) {

        return new TracingWakeLock(flags, tag);

        override fun acquire(timeout: Long) {

            synchronized(wakeLock) {

                wakeLock.acquire(timeout)

            }

            Timber.v("TracingWakeLock for tag %s / id %d for %d ms: acquired", tag, id, timeout)

    public class TracingWakeLock implements com.fsck.k9.mail.power.WakeLock {

        final WakeLock wakeLock;

        final int id;

        final String tag;

        volatile Long startTime = null;

        volatile Long timeout = null;

        public TracingWakeLock(int flags, String ntag) {

            tag = ntag;

            wakeLock = pm.newWakeLock(flags, tag);

            id = wakeLockId.getAndIncrement();

            if (K9MailLib.isDebug()) {

                Timber.v("TracingWakeLock for tag %s / id %d: Create", tag, id);

            if (startTime == null) {

                startTime = SystemClock.elapsedRealtime()

            }

            this.timeout = timeout

        }

        @Override

        public void acquire(long timeout) {

        @SuppressLint("WakelockTimeout")

        override fun acquire() {

            synchronized(wakeLock) {

                wakeLock.acquire(timeout);

            }

            if (K9MailLib.isDebug()) {

                Timber.v("TracingWakeLock for tag %s / id %d for %d ms: acquired", tag, id, timeout);

                wakeLock.acquire()

            }

            Timber.v("TracingWakeLock for tag %s / id %d: acquired with no timeout.", tag, id)

            if (startTime == null) {

                startTime = SystemClock.elapsedRealtime();

                startTime = SystemClock.elapsedRealtime()

            }

            this.timeout = timeout;

            timeout = null

        }

        @Override

        public void acquire() {

        override fun setReferenceCounted(counted: Boolean) {

            synchronized(wakeLock) {

                wakeLock.acquire();

            }

            if (K9MailLib.isDebug()) {

                Timber.w("TracingWakeLock for tag %s / id %d: acquired with no timeout.  K-9 Mail should not do this",

                        tag, id);

                wakeLock.setReferenceCounted(counted)

            }

            if (startTime == null) {

                startTime = SystemClock.elapsedRealtime();

        }

            timeout = null;

        override fun release() {

            val startTime = this.startTime

            if (startTime != null) {

                val endTime = SystemClock.elapsedRealtime()

                Timber.v(

                    "TracingWakeLock for tag %s / id %d: releasing after %d ms, timeout = %d ms",

                    tag, id, endTime - startTime, timeout

                )

            } else {

                Timber.v("TracingWakeLock for tag %s / id %d, timeout = %d ms: releasing", tag, id, timeout)

            }

        @Override

        public void setReferenceCounted(boolean counted) {

            synchronized(wakeLock) {

                wakeLock.setReferenceCounted(counted);

            }

                wakeLock.release()

            }

        @Override

        public void release() {

            if (startTime != null) {

                Long endTime = SystemClock.elapsedRealtime();

                if (K9MailLib.isDebug()) {

                    Timber.v("TracingWakeLock for tag %s / id %d: releasing after %d ms, timeout = %d ms",

                            tag, id, endTime - startTime, timeout);

                }

            } else {

                if (K9MailLib.isDebug()) {

                    Timber.v("TracingWakeLock for tag %s / id %d, timeout = %d ms: releasing", tag, id, timeout);

            this.startTime = null

        }

    }

            synchronized (wakeLock) {

                wakeLock.release();

    companion object {

        private val wakeLockId = AtomicInteger(0)

        private var tracingPowerManager: TracingPowerManager? = null

        @JvmStatic

        @Synchronized

        fun getPowerManager(context: Context): TracingPowerManager {

            return tracingPowerManager ?: createPowerManager(context.applicationContext).also {

                tracingPowerManager = it

            }

            startTime = null;

        }

        private fun createPowerManager(appContext: Context): TracingPowerManager {

            Timber.v("Creating TracingPowerManager")

            return TracingPowerManager(appContext)

        }

    }

}

 No newline at end of file