/*

* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:

*

*/

package com.nokia.mj.impl.rt.midp;

import java.io.OutputStream;

import java.io.DataOutputStream;

import java.io.IOException;

import com.nokia.mj.impl.fileutils.FileUtility;

import com.nokia.mj.impl.rt.support.JvmInternal;

/**

 * A class for storing the heap usage to a file after fixed time period.

 *

 * @author Nokia Corporation

 * @version $Rev$

 */

public class MemoryLogger extends Thread

{

    /**

     * Singleton instance of the MemoryLogger.

     */

    private static MemoryLogger     sInstance;

    // Keep the deafult values in sync with native side.

    private static final int        DEFAULT_OLD_SPACE = 64 * 1024;

    private static final int        DEFAULT_NEW_SPACE = 64 * 1024;

    private static final String     FILE_NAME = "heap";

    private static final int        MAX_OLD_SPACE = 1 * 1024 * 1024;

    /**

     * Used to stop montoring if the MIDlet is closed before the fixed timer

     * has elapsed.

     */

    private        boolean          mForcedStop = false;

    /*** ----------------------------- PRIVATE ---------------------------- */

    /**

     * Constructor of the MemoryLogger.

     */

    private MemoryLogger()

    {

    }

    /*** ----------------------------- PACKAGE ---------------------------- */

    /**

     * Starts the heap monitoring by creating a dedicated thread.

     */

    static void startMonitoring()

    {

        if (sInstance == null)

        {

            if (Log.mOn) Log.logI("Memory monitor start request");

            sInstance = new MemoryLogger();

            sInstance.start();

        }

    }

    /**

     * Closes the heap monitoring. If the timer has already elapsed this

     * method does nothing. If the not then the monitoring is interrupted.

     */

    static void close()

    {

        if (Log.mOn) Log.logI("Memory monitor close request");

        if (sInstance != null)

        {

            if (Log.mOn) Log.logI("  interrupting thread");

            sInstance.mForcedStop = true;

            sInstance.interrupt();

        }

    }

    /**

     * Gets the amount of bytes how much the old space heap should be expanded.

     */

    static int getOldHeapSizeToExpand()

    {

        int currentTotalMemory = (int)Runtime.getRuntime().totalMemory();

        int currentOldSpaceSize = currentTotalMemory - DEFAULT_NEW_SPACE;

        int oldSpaceFromPreviousRun = getRecordedHeapSize();

        int expandSize = 0;

        if (oldSpaceFromPreviousRun > DEFAULT_OLD_SPACE)

        {

            // Expanding it to recorded value.

            expandSize = oldSpaceFromPreviousRun - currentOldSpaceSize;

        }

        else

        {

            // Expanding it back to default value.

            expandSize = DEFAULT_OLD_SPACE - currentOldSpaceSize;

        }

        int highLimit = MAX_OLD_SPACE - currentOldSpaceSize;

        if (expandSize < 0)

        {

            expandSize = 0;

        }

        if (expandSize > highLimit)

        {

            expandSize = highLimit;

        }

        if (Log.mOn) Log.logI("getOldHeapSizeToExpand: " + expandSize);

        return expandSize;

    }

    /**

     * Reads the recorded heap size from possible previous runs. The heap size

     * is read from the 'heap' file located in the root path of the MIDlet.

     * @return heap size in bytes if available, 0 if not available.

     */

    static int getRecordedHeapSize()

    {

        // Construct the file name.

        String heapFile = ApplicationInfoImpl.getMidletInfo().getRootPath();

        heapFile += FILE_NAME;

        int heap = _readFile(heapFile);

        return heap;

    }

    /*** ----------------------------- PUBLIC ------------------------------ */

    /**

     * The thread will wait for fixed time and after elapsing will write the

     * heap usage into the file. If the monitoring is interrupted, then the

     * heap result will not be stored into the file.

     */

    public void run()

    {

        try

        {

            sleep(60000);

        }

        catch (Throwable t)

        {

        }

        if (mForcedStop)

        {

            if (Log.mOn) Log.logI("MIDlet closed, no memory monitoring");

            // The MIDlet was closed before timer elapsed, so no monitoring.

            sInstance = null;

            return;

        }

        try

        {

            Runtime rt = Runtime.getRuntime();

            long freeMem = rt.freeMemory();

            long totMem = rt.totalMemory();

            int usedHeap = (int)(totMem-freeMem);

            int heapSizeToStore = usedHeap - DEFAULT_NEW_SPACE;

            if (Log.mOn) Log.logI("HeapSizeToStore: " + heapSizeToStore);

            _writeFile(ApplicationInfoImpl.getMidletInfo().getRootPath()

                       + FILE_NAME, heapSizeToStore);

        }

        catch (Throwable th)

        {

            Log.logE("Error in MemoryLogger: ", th);

        }

        sInstance = null;

    }

    private native void _writeFile(String file, int heapSize);

    private static native int _readFile(String file);

}