1 /*

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

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

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

     6 * which accompanies this distribution, and is available

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

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  Writer for logging

    15  *

    16 */

    17 

    18 

    19 package com.nokia.tools.themeinstaller.logger;

    20 

    21 import java.io.File;

    22 import java.io.IOException;

    23 import java.util.logging.ConsoleHandler;

    24 import java.util.logging.FileHandler;

    25 import java.util.logging.Level;

    26 import java.util.logging.Logger;

    27 

    28 /**

    29  * Class for writing logs to file or console.

    30  * This LogWriter is a singleton version of using logging

    31  * so that there is no need to instantiate Logger in

    32  * every class that uses logs.

    33  *

    34  * NOTE: User of this class has to make sure that closeInstance() is

    35  * called when logger is no longer used. If this is not called,

    36  * the used file resources are not closed.

    37  */

    38 public class LogWriter

    39     {

    40     // The logger used in writing.

    41     private static Logger iLogger = Logger.getLogger( LogWriter.class.getName() );

    42 

    43     // Singleton instance

    44     private static LogWriter sInstance = null;

    45 

    46     // Filename for log writing

    47     private static String sLogFileName = null;

    48 

    49     // Log file constants

    50     private final static String LOG_FILENAME = "ThemeInstaller";

    51     private final static String UNDERLINE_CHARACTER = "_";

    52     private final static String LOG_FILENAME_EXTENSION = ".log";

    53 

    54     // Date format for log filename

    55     private final static String DATE_FORMAT = "yyyyMMdd_HHmmssSS";

    56 

    57     /**

    58      * Instantiates a new log writer for console.

    59      *

    60      * @param aLevel The level

    61      */

    62     private LogWriter( Level aLevel )

    63         {

    64         iLogger.setLevel( aLevel );

    65         // If level == OFF, no need to continue the instantiating

    66         if ( aLevel == Level.OFF )

    67             {

    68             return;

    69             }

    70         // Disabling parent handlers so that the console handler remains as only

    71         // handler

    72         iLogger.setUseParentHandlers( false );

    73         ConsoleHandler consoleHandler = new ConsoleHandler();

    74         consoleHandler.setFormatter( new LogFormatter() );

    75         iLogger.addHandler( consoleHandler );

    76         }

    77 

    78     /**

    79      * Instantiates a new log writer for file.

    80      *

    81      * @param aDir The directory for log files

    82      * @param aLevel The level

    83      */

    84     private LogWriter( File aDir, Level aLevel )

    85         {

    86         try

    87             {

    88             iLogger.setLevel( aLevel );

    89             // If level == OFF, no need to continue the instantiating

    90             if ( aLevel == Level.OFF )

    91                 {

    92                 return;

    93                 }

    94             // Disabling parent handlers so that the file handler remains as only

    95             // handler

    96             iLogger.setUseParentHandlers( false );

    97 

    98             String filename = validateDir( aDir );

    99 

   100             FileHandler fileHandler = new FileHandler( filename );

   101             fileHandler.setFormatter( new LogFormatter() );

   102             iLogger.addHandler( fileHandler );

   103             }

   104         catch ( IOException e )

   105             {

   106             iLogger.log( Level.SEVERE, "Unable to create logging file.", e );

   107             }

   108         }

   109 

   110     /**

   111      * Gets the level.

   112      *

   113      * @return The level

   114      */

   115     public Level getLevel()

   116         {

   117         return iLogger.getLevel();

   118         }

   119 

   120     /**

   121      * Close file.

   122      */

   123     private static void closeFile()

   124         {

   125         if ( iLogger.getHandlers().length > 0

   126         // LogWriter has maximum of 1 handler

   127                 && iLogger.getHandlers()[ 0 ] instanceof FileHandler )

   128             {

   129             iLogger.getHandlers()[ 0 ].close();

   130             }

   131         }

   132 

   133     /**

   134      * Validate that directory for logging exists.

   135      *

   136      * @param aDir The directory

   137      *

   138      * @return Log file name

   139      */

   140     private String validateDir( File aDir )

   141         {

   142         if ( aDir.isFile() )

   143             {

   144             throw new IllegalArgumentException( "Invalid log file path. Not a directory: " + aDir );

   145             }

   146 

   147         // Create directory structure

   148         if ( !aDir.exists() )

   149             {

   150             aDir.mkdirs();

   151             }

   152 

   153         return aDir + File.separator + LOG_FILENAME + UNDERLINE_CHARACTER

   154                 + LogFormatter.dateToString( DATE_FORMAT, System.currentTimeMillis() )

   155                 + LOG_FILENAME_EXTENSION;

   156         }

   157 

   158     /**

   159      * Sets the level for logging.

   160      *

   161      * @param level The logging level in scale from 0 to 7

   162      */

   163     public void setLevel( int aLevel )

   164         {

   165         if ( aLevel < 0 || 7 < aLevel )

   166             {

   167             throw new IllegalStateException(

   168                     "Trying to set invalid logging level" );

   169             }

   170         switch ( aLevel )

   171             {

   172             case 0:

   173                 iLogger.setLevel( Level.ALL );

   174                 break;

   175             case 1:

   176                 iLogger.setLevel( Level.FINEST );

   177                 break;

   178             case 2:

   179                 iLogger.setLevel( Level.FINER );

   180                 break;

   181             case 3:

   182                 iLogger.setLevel( Level.FINE );

   183                 break;

   184             case 4:

   185                 iLogger.setLevel( Level.CONFIG );

   186                 break;

   187             case 5:

   188                 iLogger.setLevel( Level.INFO );

   189                 break;

   190             case 6:

   191                 iLogger.setLevel( Level.WARNING );

   192                 break;

   193             case 7:

   194                 iLogger.setLevel( Level.SEVERE );

   195                 break;

   196             default:

   197                 break;

   198             }

   199         }

   200 

   201     /**

   202      * Check if logger is in console mode.

   203      *

   204      * @return true, if Logger is writing on console

   205      */

   206     public boolean inConsoleMode()

   207         {

   208         if ( iLogger.getHandlers().length > 0

   209                 // LogWriter has maximum of 1 handler

   210                 && iLogger.getHandlers()[ 0 ] instanceof ConsoleHandler )

   211             {

   212             return true;

   213             }

   214         return false;

   215         }

   216 

   217     /**

   218      * Log severe.

   219      *

   220      * @param aMessage The message for logging

   221      */

   222     public void logSevere( String aMessage )

   223         {

   224         iLogger.log( Level.SEVERE, aMessage );

   225         }

   226 

   227     /**

   228      * Log warning.

   229      *

   230      * @param aMessage The message for logging

   231      */

   232     public void logWarning( String aMessage )

   233         {

   234         iLogger.log( Level.WARNING, aMessage );

   235         }

   236 

   237     /**

   238      * Log info.

   239      *

   240      * @param aMessage The message for logging

   241      */

   242     public void logInfo( String aMessage )

   243         {

   244         iLogger.log( Level.INFO, aMessage );

   245         }

   246 

   247     /**

   248      * Log message.

   249      *

   250      * @param aMessage The message for logging

   251      */

   252     public void logConfig( String aMessage )

   253         {

   254         iLogger.log( Level.CONFIG, aMessage );

   255         }

   256 

   257     /**

   258      * Log fine.

   259      *

   260      * @param aMessage The message for logging

   261      */

   262     public void logFine( String aMessage )

   263         {

   264         iLogger.log( Level.FINE, aMessage );

   265         }

   266 

   267     /**

   268      * Closes singleton resources and removes the singleton instance

   269      */

   270     public static synchronized void closeInstance()

   271         {

   272         closeFile();

   273         sInstance = null;

   274         }

   275 

   276     /**

   277      * Gets the single instance of LogWriter.

   278      * Note that initialize method has to be called

   279      * before this.

   280      *

   281      * @return Single instance of LogWriter

   282      */

   283     public static synchronized LogWriter getInstance()

   284         {

   285         if ( sInstance == null )

   286             {

   287             // Initialize method not called yet

   288             sInstance = new LogWriter( Level.OFF );

   289             }

   290         return sInstance;

   291         }

   292 

   293     /**

   294      * Initialize new instance of LogWriter.

   295      * Note that the default logging level is Level.ALL.

   296      *

   297      * @param aDir The directory for writing log

   298      *

   299      * @throws IOException Signals that an I/O exception has occurred.

   300      */

   301     public static void initialize( File aDir ) throws IOException

   302         {

   303         // Already initialized if:

   304         // sInstance is not null AND

   305         // sLogFileName equals with aLogFile

   306 

   307         if ( sInstance != null &&

   308            ( sLogFileName != null && aDir != null && sLogFileName.equals( aDir.getPath() ) ||

   309            ( sLogFileName == null && aDir == null ) ) )

   310             {

   311             return;

   312             }

   313 

   314         // Create a new instance

   315         // If no log file given, the log is written in console

   316         if ( aDir == null )

   317             {

   318             sInstance = new LogWriter( Level.ALL );

   319             sLogFileName = null;

   320             }

   321         else

   322             {

   323             sInstance = new LogWriter( aDir, Level.ALL );

   324             sLogFileName = aDir.getPath();

   325             }

   326         }

   327     }