diff -r 4ad59aaee882 -r 2f468c1958d0 javauis/nokiauiapi_qt/javasrc/com/nokia/mid/ui/SoftNotificationImpl.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/javauis/nokiauiapi_qt/javasrc/com/nokia/mid/ui/SoftNotificationImpl.java Mon Oct 04 00:10:53 2010 +0300 @@ -0,0 +1,353 @@ +/* + * 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.mid.ui; + +import java.io.ByteArrayInputStream; +import java.io.IOException; +import java.io.OutputStream; + +import org.eclipse.swt.internal.extension.DisplayExtension; +import org.eclipse.swt.widgets.Internal_PackageSupport; + +import com.nokia.mid.ui.internal.OS; +import com.nokia.mid.ui.SoftNotificationException; +import com.nokia.mid.ui.SoftNotificationListener; +import com.nokia.mj.impl.fileutils.FileUtility; +import com.nokia.mj.impl.rt.support.Finalizer; +import com.nokia.mj.impl.rt.support.ApplicationInfo; + +/** + * SoftNotificationImpl implements the functionality specified in + * com.nokia.mid.ui.SoftNotification class. + */ +final class SoftNotificationImpl extends com.nokia.mid.ui.SoftNotification { + + // Native CSoftNotification handle + private int iSoftNotificationHandle = 0; + + // Observer of this class set by the API user. An array is used to allow + // listener synchronization. + private SoftNotificationListener[] iListener; + + // Listener event when user accepted notification + private final static int EVENT_ACCEPT = 1; + + // Listener event when user dismissed notification + private final static int EVENT_DISMISS = 2; + + // Error message prefix for exceptions. + private final static String ERROR_MESSAGE_PREFIX = "Failed to "; + + // The class will have native resources so register it for + // finalization. + private Finalizer mFinalizer; + + private int err; + + private int id; + + private int midletUid; + + /** + * Constructor. New instance with old identifier. + * + * @param aNotificationId + * Identification of previous soft notification. + */ + public SoftNotificationImpl(int aNotificationId) { + initialize(aNotificationId); + } + + /** + * Constructor. New instance. + */ + public SoftNotificationImpl() { + initialize(0); + } + + /** + * Initializes the instance. + * + * @param aNotificationId + * Id of the soft notification. + */ + protected void initialize(int aNotificationId) { + final int iNotificationId = aNotificationId; + iListener = new SoftNotificationListener[1]; + + Runnable r = new Runnable() { + public void run() { + String uidString = ApplicationInfo.getInstance().getUid().toString(); + // removing "[" and "]" brackets + uidString = uidString.substring(1,uidString.length()-1); + // converting to decimal + midletUid =(int)Long.parseLong(uidString,16); + iSoftNotificationHandle = OS.createNativePeer(midletUid, iNotificationId, + SoftNotificationImpl.this); + } + }; + // if display is created already, execute it in UI thread no matter + // what thread it is called from. Otherwise assume LCDUI application is + // called + // and create a display. eSWT is not allowed to call before display + // creation + if (DisplayExtension.getDisplayInstance() != null) { + DisplayExtension.getDisplayInstance().syncExec(r); + } else { + com.nokia.mj.impl.nokialcdui.LCDUIInvoker + .eSWTUIThreadRunnerSyncExec(r); + } + + if (iSoftNotificationHandle <= 0) { + throw new OutOfMemoryError(); + } + + mFinalizer = ((mFinalizer != null) ? mFinalizer : new Finalizer() { + public void finalizeImpl() { + close(); + } + }); + } + + /** + * Called when the object is finalized by the garbage collector. + */ + public void close() { + if (DisplayExtension.getDisplayInstance() != null) { + Internal_PackageSupport.getDisplayInstance().syncExec(new Runnable() { + public void run() { + if (mFinalizer != null) { + OS.destroy(iSoftNotificationHandle); + } + mFinalizer = null; + } + }); + } + } + + /** + * Notification callback, called from the native side. + * + * @param aEventArg + * Occurred event. + */ + private void notificationCallback(int aEventArg) { + // Synchronize the listener usage since the user may want to set it + // to null during execution of this function. + synchronized (iListener) { + SoftNotificationListener listener = iListener[0]; + + if (listener != null) { + if (aEventArg == EVENT_ACCEPT) { + listener.notificationSelected(this); + } else if (aEventArg == EVENT_DISMISS) { + listener.notificationDismissed(this); + } + } + } + } + + /** + * Checks the given error value. Throws SoftNotificationException if the + * given error value is other than NativeError.KErrNone. + * + * @param aError + * Error value to be checked. + * @param aErrorMessage + * Message to be included in the exception. + */ + private final void checkError(int aError, String aErrorMessage) + throws SoftNotificationException { + if (aError != 0) { + throw new SoftNotificationException(ERROR_MESSAGE_PREFIX + + aErrorMessage, aError); + } + } + + // Functions from the base class. + + /** + * See class SoftNotification for comments + */ + public int getId() { + if (DisplayExtension.getDisplayInstance() != null) { + Internal_PackageSupport.getDisplayInstance().syncExec( + new Runnable() { + public void run() { + id = 0; + id = OS.getId(iSoftNotificationHandle); + } + }); + } + return id; + } + + /** + * See class SoftNotification for comments + */ + public void post() throws SoftNotificationException { + if (DisplayExtension.getDisplayInstance() != null) { + Internal_PackageSupport.getDisplayInstance().syncExec( + new Runnable() { + public void run() { + err = 0; + err = OS + .showSoftNotification(iSoftNotificationHandle); + } + }); + } + checkError(err, "add soft notification"); + } + + /** + * See class SoftNotification for comments + */ + public void remove() throws SoftNotificationException { + if (DisplayExtension.getDisplayInstance() != null) { + Internal_PackageSupport.getDisplayInstance().syncExec( + new Runnable() { + public void run() { + err = 0; + err = OS + .removeSoftNotification(iSoftNotificationHandle); + } + }); + } + checkError(err, "remove notification"); + } + + /** + * See class SoftNotification for comments + */ + public void setListener(SoftNotificationListener aListener) { + // Synchronize the listener setting since the user may set it + // to null during it is used elsewhere in this class. + synchronized (iListener) { + iListener[0] = aListener; + } + } + + /** + * See class SoftNotification for comments + */ + public void setText(String aPrimaryText, String aSecondaryText) + throws SoftNotificationException { + final String iPrimaryText = aPrimaryText; + final String iSecondaryText = aSecondaryText; + + if (DisplayExtension.getDisplayInstance() != null) { + Internal_PackageSupport.getDisplayInstance().syncExec( + new Runnable() { + public void run() { + err = 0; + err = OS.setText(iSoftNotificationHandle, + iPrimaryText == null ? "" : iPrimaryText, + iSecondaryText == null ? "" + : iSecondaryText); + } + }); + } + checkError(err, "set note text"); + } + + /** + * See class SoftNotification for comments + */ + public void setSoftkeyLabels(String aSoftkey1Label, String aSoftkey2Label) + throws SoftNotificationException { + int err = 0; + checkError(err, "set softkeys"); + } + + private String stringReplace(String source, String searchStr, + String replacementStr) { + StringBuffer strBuffer = new StringBuffer(); + int pos = source.indexOf(searchStr); + + while (pos != -1) { + strBuffer.append(source.substring(0, pos)).append(replacementStr); + source = source.substring(pos + searchStr.length()); + pos = source.indexOf(searchStr); + } + strBuffer.append(source); + return strBuffer.toString(); + } + + /** + * See class SoftNotification for comments + */ + public void setImage(byte[] aImageData) throws SoftNotificationException { + if (aImageData != null) { + final byte[] iImageData = aImageData; + if (DisplayExtension.getDisplayInstance() != null) { + Internal_PackageSupport.getDisplayInstance().syncExec( + new Runnable() { + public void run() { + err = 0; + String imagePath = ""; + try { + String directoryPath = ApplicationInfo + .getInstance().getRootPath(); + // Replace "\private\102033e6\apps" with + // "resource\apps\java" + directoryPath = stringReplace( + directoryPath, "private", "public"); + directoryPath = directoryPath + + "softnotification\\" + + midletUid + "_" + + getId(); + String imageName = midletUid + + "_" + getId(); + FileUtility target = new FileUtility( + directoryPath); + if (!target.exists()) { + target.mkdirs(); + } + target = new FileUtility(directoryPath + + "\\" + imageName); + if (!target.exists()) { + target.createNewFile(); + } + OutputStream fos = target + .openOutputStream(); + ByteArrayInputStream in = new ByteArrayInputStream( + iImageData); + byte[] buf = new byte[1024]; + int len; + while ((len = in.read(buf)) > 0) { + fos.write(buf, 0, len); + } + in.close(); + fos.close(); + target = null; + imagePath = directoryPath + "\\" + + imageName; + } catch (IOException ex) { + ex.printStackTrace(); + } catch (Throwable t) { + t.printStackTrace(); + } + err = OS.setImagePath(iSoftNotificationHandle, + imagePath); + } + }); + } + } + checkError(err, "set image"); + } +}