/*
* Copyright (c) 2010 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.installer.utils;

/**
 * Provides notifications whenever the subscribed property value changes.
 * <br>
 * One PropertyProvider instance can be used to subscribe events
 * for only one property. If events for more properties are needed
 * use separate PropertyProvider instance for each property.
 *
 * @see PropertyListener
 */
public class PropertyProvider
{
    /** Property category. */
    private int iCategory = 0;
    /** Property key. */
    private int iKey = 0;
    /** Property listener. */
    private PropertyListener iListener = null;
    /** Handle to native object. */
    private int iHandle = 0;

    /**
     * Constructor.
     */
    public PropertyProvider()
    {
    }

    /**
     * Subscribe to listen changes of specified property value.
     * One PropertyListener can subscribe to only one property
     * value at a time.
     *
     * @param aCategory property category
     * @param aKey property key
     * @param aListener listener to be notified.
     */
    public void subscribe(int aCategory, int aKey, PropertyListener aListener)
    {
        if (iHandle != 0)
        {
            InstallerException.internalError("PropertyProvider already in use.");
        }
        iCategory = aCategory;
        iKey = aKey;
        iListener = aListener;
        // Start a new thread which blocks until unsubscribe is called.
        final PropertyProvider provider = this;
        new Thread(new Runnable()
        {
            public void run()
            {
                synchronized (provider)
                {
                    iHandle = _subscribe(iCategory, iKey);
                    // Notify subscribe method after subscription
                    // result is available.
                    provider.notify();
                }
                if (iHandle > 0)
                {
                    // Subscription succeeded, start to process events.
                    _processEvents(iHandle, provider);
                }
            }
        }, "PropertyProviderThread").start();
        synchronized (this)
        {
            try
            {
                if (iHandle == 0)
                {
                    // Wait until subscription has been completed.
                    wait();
                }
            }
            catch (InterruptedException ie)
            {
            }
        }
        // Check if subscription failed.
        if (iHandle < 0)
        {
            Log.logError("PropertyProvider.subscribe failed with code " + iHandle);
            iHandle = 0;
        }
    }

    /**
     * Unubscribe from listening changes.
     */
    public void unsubscribe()
    {
        final PropertyProvider provider = this;
        new Thread(new Runnable()
        {
            public void run()
            {
                synchronized (provider)
                {
                    if (iHandle <= 0)
                    {
                        Log.logWarning(
                            "PropertyProvider.unsubscribe: no subscription.");
                        return;
                    }
                    int err = _unsubscribe(iHandle);
                    if (err < 0)
                    {
                        Log.logError(
                            "PropertyProvider.unsubscribe failed with code " +
                            err);
                    }
                    else
                    {
                        iHandle = 0;
                    }
                }
            }
        }, "PropertyProviderUnsubscribeThread").start();
    }

    /**
     * Called from native when value for the subscribed property changes.
     */
    private void valueChanged(int aValue)
    {
        if (iListener != null)
        {
            iListener.valueChanged(iCategory, iKey, aValue);
        }
    }

    /**
     * Subscribe to listen changes of specified property value.
     *
     * @param aCategory property category
     * @param aKey property key
     * @return handle to native side object or Symbian error
     * code (negative number)
     */
    private static native int _subscribe(int aCategory, int aKey);

    /**
     * Starts to process events. This call blocks until unsubscribe is called.
     *
     * @param aHandle handle to native side object
     * @param aProvider PropertyProvider class instance to be notified
     * @return 0 or Symbian error code (negative number)
     */
    private static native int _processEvents(int aHandle, PropertyProvider aProvider);

    /**
     * Unubscribe from listening changes.
     *
     * @param aHandle handle to native side object
     * @return 0 or Symbian error code (negative number)
     */
    private static native int _unsubscribe(int aHandle);
}