1 #

     2 # Copyright (c) 2010 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: 

    15 #

    16 

    17 use strict;

    18 use warnings;

    19 use File::Spec::Functions;

    20 use Getopt::Long;

    21 use Pod::Usage;

    22 

    23 # Version of the script - just use the date

    24 $main::VERSION = '12-July-2010';

    25 

    26 # New getopt::long provides this - but old version doesn't?

    27 sub version

    28   {

    29   print sprintf("$0: $main::VERSION\n$^X: %vd\nos: $^O", $^V);

    30   exit;

    31   }

    32 

    33 # Get arguments

    34 my ( $help, $version, $verbose, $debug, $epocroot, $l10n );

    35 GetOptions( "help" => \$help, "version|ver" => \$version,

    36       "verbose|v" => \$verbose,  "debug" => \$debug,

    37       "epocroot|e=s" => \$epocroot, "localization|l=s" => \$l10n )

    38   or pod2usage('Invalid parameters');

    39 

    40 # Handle help and version

    41 pod2usage({ verbose => 1, exitval => 0}) if $help;

    42 version() if $version;

    43 

    44 # Interpret arguments

    45 $verbose = 1 if $debug;

    46 $verbose = $verbose ? '-v' : '';

    47 $epocroot = $ENV{EPOCROOT} if !$epocroot;

    48 

    49 # Interpret localization l10n argument

    50 

    51 # There are two modes.  In one mode you specify the location of a

    52 # lproj.xml file and the code computes l10n files for all languages so

    53 # that runtime locale selection should work.  In the other mode you

    54 # specify a language code (example, fr for French) and the code

    55 # computes l10n just for that language.

    56 $l10n = '' if !$l10n;

    57 my $lproj = '';

    58 if ($l10n =~ /lproj\.xml$/i)

    59   {

    60   $lproj = $l10n;

    61   $l10n = '';

    62   }

    63 

    64 my ($configini, @unnecessary) = @ARGV;

    65 

    66 if ($configini)

    67   {

    68   # There shouldn't be any need for any other arguments

    69   pod2usage('Unnecessary arguments supplied.') if @unnecessary;

    70 

    71   # Now do the installation

    72   my $installer = WidgetInstaller->new('verbose' => $verbose, 'debug' => $debug, 'epocroot' => $epocroot, 'lproj' => $lproj, 'l10n' => $l10n);

    73   $installer->installConfig($configini);

    74   }

    75 else

    76   {

    77   pod2usage('Missing config.ini argument.');

    78   }

    79 

    80 # ***

    81 # Package for installing Widgets

    82 #

    83 

    84 package WidgetInstaller;

    85 

    86 use File::Spec::Functions;

    87 use File::Path;

    88 use File::Basename;

    89 use Unicode::String qw(utf8 utf16);

    90 use File::Temp qw/tempdir/;

    91 use File::Copy;

    92 use XML::Parser;

    93 use Data::Dumper;

    94 use XML::Simple;

    95 

    96 # CONSTANTS

    97 use constant ICON_SIZES => "88,32,24";      # Size of icons to generate in the MBM file

    98 #use constant INTERNAL_UID_LOWER => 0x2000DAD2; # Lower UID bound for midlets installed to internal drives and rom

    99 #use constant EXTERNAL_UID_LOWER => 0x2000DCC6; # Lower UID bound for midlets installed to removable cards

   100 use constant INTERNAL_UID_LOWER_WRT => 0x2000DAD2;  # Lower UID bound for WRT widgets installed to internal drives and rom

   101 use constant INTERNAL_UID_LOWER_CWRT => 0x2000DBCC; # Lower UID bound for CWRT widgets installed to internal drives and rom

   102 use constant EXTERNAL_UID_LOWER_WRT => 0x2000DCC6;  # Lower UID bound for WRT widgets installed to removable cards

   103 use constant EXTERNAL_UID_LOWER_CWRT => 0x2000DDC0; # Lower UID bound for CWRT widgets installed to removable cards

   104 use constant WIDGET_UI_UID => 0x10282822;   # UID of the widget app

   105 use constant CWRT_WIDGET_UI_UID => 0x200267C0;    # UID of the cwrt widget app

   106 use constant SWIDGET_UI_UID => 0x102829A0;	# UID of the securewidget app

   107 use constant CWRT_WIDGET_UI_NON_NOKIA_UID => 0x200267D6;    # UID of the cwrt widget app

   108 

   109 # Folder paths

   110 use constant DESTINATION => 'private/10003a3f/import/apps/NonNative/Resource';

   111 use constant ROM_DEST => 'epoc32/release/winscw/udeb/Z/';

   112 use constant DRIVE_DEST => 'epoc32/winscw/%s';

   113 use constant WIDGET_REGISTRY => 'private/10282f06/WidgetEntryStore.xml';

   114 use constant CWRT_WIDGET_REGISTRY => 'private/10282f06/CWRTWidgetEntryStore.xml';

   115 use constant CWRT_WEBAPP_REGISTRY => 'private/200267D9/webapp_registry.db';

   116 use constant CWRT_ACCESS_POLICY_PATH => 'browser_access_policy.xml';

   117 use constant WIDGET_NAME => 'en-gb/widget/name';

   118 use constant WIDGET_PROCESSUID => 'processUid';

   119 use constant WIDGET_ID => 'widget/id';

   120 use constant WIDGET_VERSION => 'widget/version';

   121 use constant WIDGET_CONTENT => 'widget/content';

   122 use constant WIDGET_FEATURE => 'widget/feature/';

   123 use constant WIDGET_FEATURE_PARAM => '/param/';

   124 use constant WIDGET_ACCESS => 'widget/access/';

   125 use constant WIDGET_HEIGHT => 'widget/height';

   126 use constant WIDGET_WIDTH => 'widget/width';

   127 use constant WIDGET_NOKIA_SHAREDLIB => 'widget/NOKIA:sharedlibrary';

   128 use constant WIDGET_NOKIA_SHAREDLIB_FOLDER => 'widget/NOKIA:sharedlibrary/NOKIA:folder';

   129 use constant WIDGET_NOKIA_SHAREDLIB_WIDGET => 'widget/NOKIA:sharedlibrary/NOKIA:widget';

   130 use constant WIDGET_NOKIA_SHAREDLIB_ICON => 'widget/NOKIA:sharedlibrary/NOKIA:icon';

   131 use constant KEY_VALUE_SEPERATOR => ',';

   132 use constant KEY_VALUE_PAIR_SEPERATOR => ';';

   133 use constant KEY_ATTR_SEPERATOR => ':';

   134 

   135 our $w3c_widget = 0 ;

   136 our $hashval;

   137 our $non_nokia_widget = 0;

   138 our ($isSharedLibrary, $sharedFolderName ,$isSharedWidget, $isSharedIcon)= (0,'',0,0);

   139 our (@staticUidWrtIntList,@staticUidCwrtIntList,@staticUidWrtExtList,@staticUidCwrtExtList) = ({},{},{},{});

   140 our $isSecureWidget = 0;

   141 

   142 # Create a new object

   143 sub new

   144   {

   145   my $invocant = shift;

   146   my $self = bless({}, ref $invocant || $invocant);

   147 

   148   my %args = @_;

   149   $self->{'args'} = \%args;

   150   $self->{'args'}->{'verbose'} = $self->{'args'}->{'verbose'} ? '-v' : '';

   151 

   152   $self->{'installedFiles'} = ();

   153   $self->{'freeuidwrtint'} = INTERNAL_UID_LOWER_WRT;

   154   $self->{'freeuidwrtext'} = EXTERNAL_UID_LOWER_WRT;

   155   $self->{'freeuidcwrtint'} = INTERNAL_UID_LOWER_CWRT;

   156   $self->{'freeuidcwrtext'} = EXTERNAL_UID_LOWER_CWRT;

   157   $self->{'langmapping'} = $self->getLangMapping($self->{'args'}->{'lproj'}) unless $self->{'args'}->{'l10n'};

   158   

   159   #Check if localisation argument is land number ID; If true, get the lang Name using langmapping file - Widget_lproj.xml 

   160   if ($l10n =~ /\d+$/)

   161   {

   162     print "\nLANG ID given as localisation argument :: $l10n \n";

   163     $self->{'langmapping'} = $self->getLangMapping();

   164     

   165     if($self->{'langmapping'})

   166     {

   167       # Iterate through all the languages we know about

   168       for(my $i = 0; $i < scalar(@{ $self->{'langmapping'}->{LangID} }); $i++)

   169       {

   170         my ( $langid, $langname ) = ( $self->{'langmapping'}->{LangID}->[$i], $self->{'langmapping'}->{LangDir}->[$i] );

   171         if($l10n == $langid)

   172         {

   173           print "Setting argument to LangName - $langname \n";

   174           $self->{'args'}->{'l10n'} = lc($langname);

   175           last;

   176         }

   177       }

   178     }

   179   }

   180 

   181   return $self;

   182   }

   183   

   184 # Gets the language mapping from the Widget_lproj.xml file

   185 sub getLangMapping

   186   {

   187   my ( $self, $lproj ) = @_;

   188 

   189   # Get the LPROJ file which specifies lang id mappings

   190   if (!$lproj)

   191     {

   192     (my $EPOCROOT = $ENV{EPOCROOT}) =~ s/[\/\\]+$//;

   193     $lproj = WidgetInstaller::fixFilename("${epocroot}epoc32/winscw/c/private/10282f06/Widget_lproj.xml");

   194     $lproj = WidgetInstaller::fixFilename("$EPOCROOT/epoc32/winscw/c/private/10282f06/Widget_lproj.xml") if !-e $lproj;

   195     $lproj = WidgetInstaller::fixFilename("${epocroot}epoc32/data/Z/private/10282f06/Widget_lproj.xml") if !-e $lproj;

   196     $lproj = WidgetInstaller::fixFilename("$EPOCROOT/epoc32/data/Z/private/10282f06/Widget_lproj.xml") if !-e $lproj;

   197     $lproj = WidgetInstaller::fixFilename("${epocroot}S60/mw/web/WebEngine/WidgetRegistry/Data/Widget_lproj.xml") if !-e $lproj;

   198     $lproj = WidgetInstaller::fixFilename("$EPOCROOT/S60/mw/web/WebEngine/WidgetRegistry/Data/Widget_lproj.xml") if !-e $lproj;

   199     $lproj = WidgetInstaller::findCmd('Widget_lproj.xml') if !-e $lproj;

   200     $lproj = WidgetInstaller::findCmd('internal/Widget_lproj.xml') if !-e $lproj;

   201     undef $lproj if !-e $lproj;

   202 

   203     # Display a warning if localisation can't be performed

   204     warn "WARNING: Can't find Widget_lproj.xml - localisation is disabled.\n" if !$lproj;

   205     }

   206 

   207   # Load the mapping file

   208   if ($lproj)

   209     {

   210     die "Can't find $lproj file." if !-e $lproj;

   211     print "Localisation support enabled using config: $lproj\n" if $verbose;

   212     my $mapping = XMLin($lproj);

   213     print "Found ", scalar(@{ $mapping->{'LangID'} }), " language mappings.\n" if $verbose;

   214     return $mapping;

   215     }

   216   }

   217 

   218 # Install Widgets listed in config file

   219 # Format is as follows where "drive-z" specifies widgets for drive z: etc...

   220 # Comments are okay - they start with a # character

   221 # If the file doesn't exist as given then EPOCROOT is prepended to the filename to try and find it

   222 #

   223 # You can specify whether a widget is intended for the homescreen by adding the text [HomeScreen] after the filename

   224 # This will set the BlanketPermissionGranted attribute in the registry.

   225 # Widgets intended for the homescreen must have the MiniViewEnabled attribute set in its PLIST file otherwise an error is generated.

   226 #

   227 # You can specify commands to run before exit after a [run-commands] or [homescreen-processor] 

   228 #

   229 # [drive-z]

   230 # \path\widget1.wgz

   231 # widget2.wdgt.zip [HomeScreen]

   232 #

   233 # [drive-e]

   234 # widget3.wgz

   235 #

   236 # [run-commands]

   237 # dostuff.pl

   238 #

   239 

   240 sub installConfig

   241   {

   242   my ( $self, $file ) = @_;

   243   $self->{'installedFiles'} = ();

   244 

   245   my ( %installData, $sectionName );

   246   open CONFIG, $file or die "Failed to open config file $file: $!";

   247   

   248   # Loop for gathering STATIC UIDs allocated for widgets in config INI file

   249   while(my $line = <CONFIG>)

   250   {

   251     # Ignore comments

   252     $line =~ s/\#.*$//;

   253     

   254     if ($line =~ /^\[([^\]]+)\]/)

   255       {

   256       $sectionName = lc $1;

   257       next;

   258       }

   259 

   260     # Process sections after this point

   261     next if !$sectionName;

   262     chomp $line;

   263 

   264     # Have we found a list of widgets?

   265     if ($sectionName =~ /^drive-([a-z])/)

   266     {

   267       my $drive = uc($1);

   268       #Assuming Static UID given in ini are within int/ext/wgt/wgz specified ranges

   269       # Add Static UID to the respective list

   270       if ($line =~ /^(.+?\.(?:wdgt\.zip|wgz|wgt))\s*(\[HomeScreen\])?\s*(0x[a-fA-F0-9]{8})?\s*(\[Operator\])?\s*$/i)

   271       {

   272         if ($3)

   273         {

   274           my $uid = hex($3);

   275           

   276           if ($drive =~ /^[zcZC]/)

   277           {

   278             if(($uid >= INTERNAL_UID_LOWER_WRT) && ($uid < INTERNAL_UID_LOWER_CWRT))

   279             {

   280               push(@staticUidWrtIntList,$uid) ;

   281             }

   282             else

   283             {

   284               push(@staticUidCwrtIntList,$uid);

   285             }

   286           }

   287           else

   288           {

   289             if(($uid >= EXTERNAL_UID_LOWER_WRT) && ($uid < EXTERNAL_UID_LOWER_CWRT))

   290             {

   291               push(@staticUidWrtExtList,$uid) ;

   292             }

   293             else

   294             {

   295               push(@staticUidCwrtExtList,$uid) ;

   296             }

   297           }

   298         }

   299       }

   300     }

   301   }

   302   close CONFIG;

   303   @staticUidWrtIntList = sort(@staticUidWrtIntList);

   304   print "SORTED WRT INTERNAL STATIC UID  @staticUidWrtIntList \n";

   305   @staticUidCwrtIntList = sort(@staticUidCwrtIntList);

   306   print "SORTED CWRT INTERNAL STATIC UID  @staticUidCwrtIntList \n";

   307   @staticUidWrtExtList = sort(@staticUidWrtExtList);

   308   print "SORTED WRT EXTERNAL STATIC UID @staticUidWrtExtList \n";

   309   @staticUidCwrtExtList = sort(@staticUidCwrtExtList);

   310   print "SORTED CWRT EXTERNAL STATIC UID @staticUidCwrtExtList \n";

   311   

   312   open CONFIG, $file or die "Failed to open config file $file: $!";

   313   # Main loop which reads the config INI line by line and installs widgets[wgz/wgt] in respective drives

   314   while(my $line = <CONFIG>)

   315     {

   316     # Ignore comments

   317     $line =~ s/\#.*$//;

   318 

   319     if ($line =~ /^\[([^\]]+)\]/)

   320       {

   321       $sectionName = lc $1;

   322       

   323       # Remember destination if any specified

   324       if ($sectionName =~ /^drive-([a-z])=(.+)$/)

   325         {

   326         $self->{'destination'}->{uc($1)} = $2;

   327         }

   328       next;

   329       }

   330 

   331     # Process sections after this point

   332     next if !$sectionName;

   333     chomp $line;

   334 

   335     # Have we found a list of widgets?

   336     if ($sectionName =~ /^drive-([a-z])/)

   337       {

   338       my $drive = uc($1);

   339       

   340       # Add to the list of Widget files

   341       if ($line =~ /^(.+?\.(?:wdgt\.zip|wgz|wgt))\s*(\[HomeScreen\])?\s*(0x[a-fA-F0-9]{8})?\s*(\[Operator\])?\s*$/i)

   342         {

   343         my $widget = $1;

   344         $widget = fixFilename(catfile($self->{'args'}->{'epocroot'}, $1)) if !-e $widget;

   345         die "Can't find widget $widget" if !-e $widget;

   346         $self->{'homescreen'}{lc $widget} = 1 if $2; # Intended for the homescreen?

   347         $self->{'staticUID'}{lc $widget} = hex($3) if $3;

   348         $self->{'secure'}{lc $widget} = 0;

   349         $self->{'operator'}{lc $widget} = 1 if $4;

   350         print "Widget for drive $drive: $widget\n" if $self->{'args'}->{'verbose'};

   351         push @{ $installData{"$drive:"} }, $widget;

   352         }

   353       elsif ($line =~ /^(.+?\.(?:wdgt\.zip|wgz))\s*(\[Secure\])?\s*(0x[a-fA-F0-9]{8})?\s*$/i)

   354         {

   355           my $widget = $1;

   356           $widget = fixFilename(catfile($self->{'args'}->{'epocroot'}, $1)) if !-e $widget;

   357           die "Can't find widget $widget" if !-e $widget;

   358           $self->{'secure'}{lc $widget} = 1 if $2; # Intended for a secure widget handling?

   359           $self->{'staticUID'}{lc $widget} = hex($3) if $3;

   360           print "Widget for drive $drive: $widget\n" if $self->{'args'}->{'verbose'};

   361           push @{ $installData{"$drive:"} }, $widget;

   362         }

   363       else

   364       	{

   365       		my $widget = $1;

   366       		$self->{'secure'}{lc $widget} = 0;

   367         }	

   368       }

   369     # Retrieve the command to execute before exit

   370     elsif ($sectionName =~ /^(run-commands|homescreen-processor)$/i && $line)

   371       {

   372       push @{ $self->{'exitcmds'} }, $line;

   373       }

   374     }

   375   close CONFIG;

   376 

   377   # Now intall the widgets for each drive specified in the config file

   378   foreach my $drive ( keys %installData )

   379     {

   380     $self->installFiles($drive, $installData{$drive} );

   381     $self->makeIBY($drive);

   382     $self->makeIBY($drive, 'localised') unless $self->{'args'}->{'l10n'};

   383     }

   384   

   385   # Exit commands at the end of the process

   386   if ($self->{'exitcmds'})

   387     {

   388     foreach my $cmd ( @{ $self->{'exitcmds'} } )

   389       {

   390       print "Executing: $cmd\n" if $self->{'args'}->{'verbose'};

   391       warn "WARNING: error running $cmd" if system($cmd) != 0;

   392       }

   393     }

   394   }

   395 

   396 # ***

   397 # Installs files to a drive

   398 #

   399 sub installFiles

   400   {

   401   my ( $self, $drive, $fileList ) = @_;

   402   my $startsrc ;

   403     my $iconsrc ;

   404   

   405    $isSharedLibrary = 0;

   406    $isSharedWidget = 0;

   407    $isSharedIcon = 0;

   408    $sharedFolderName ='';

   409    $isSecureWidget = 0;

   410     

   411   print "Installing files for drive $drive\n" if $self->{'args'}->{'verbose'};

   412 

   413   # Unregister any existing widgets as otherwise when the registry is rewritten their icons will appear in the emulator but they won't work

   414   $self->unregisterWidgets($drive);

   415 

   416   print "\n			INSTALLING FILES FOR DRIVE $drive				\n"; 

   417   # Process each widget in turn

   418   my ( @installedProps );

   419   my ( @installedCWRTProps );

   420   foreach my $filename ( @$fileList )

   421     {

   422     # Check the file exists

   423     die "Can't find $filename" if !-e $filename;

   424 

   425     # Create a temporary folder

   426     print "\nInstalling $filename\n";

   427     my $tempdir = tempdir ( DIR => '.', CLEANUP => !$self->{args}->{'debug'});

   428 

   429     # Prefer to use 7zip rather than unzip because it's better behaved wrt Unicode

   430     if (findCmd('7z.exe'))

   431       {

   432       $self->un7zipWidget($filename, $tempdir);

   433       }

   434     else

   435       {

   436       $self->unzipWidget($filename, $tempdir);

   437       }

   438         my $widgetdata ;

   439         

   440         $isSharedLibrary = 0;

   441         $isSharedWidget = 0;

   442         $isSharedIcon = 0;

   443         $sharedFolderName ='';

   444     

   445     my ( $root, $extracted, $size ) = $self->getFiles($tempdir);

   446     die "No files extracted from $filename" if !@$extracted;

   447     

   448     if ($self->{'operator'}{lc $filename})

   449 		{

   450     	print "\n NON NOKIA WGT \n";

   451     	$non_nokia_widget = 1;

   452     }

   453     else

   454     {

   455     	print "\n NOKIA WGT \n";

   456     	$non_nokia_widget = 0;

   457     }

   458     

   459     

   460     if (($filename =~ /.wgz/ )&& (my $plist = catfile($tempdir, $root, 'Info.plist')))

   461       {

   462           print ("S60 widget \n");

   463           

   464           $w3c_widget = 0;

   465           # Parse the XML file into a hash

   466               $widgetdata = parsePList($plist);

   467       }

   468     elsif (($filename =~ /.wgt/ ) && ( my $confxml = catfile($tempdir, $root, 'config.xml')))

   469       {

   470         print (" W3C widget \n"); 

   471       

   472           # Parse the XML file into a hash

   473             $widgetdata = parseConfXml($confxml,$self->{'args'}->{'l10n'});

   474             $w3c_widget = 1;

   475       }

   476     else

   477       {

   478       die "Can't find $root/Info.plist , $root/config.xml file";

   479       }       

   480 		

   481 	  if ($self->{'secure'}{lc $filename}){

   482 		$isSecureWidget = 1;

   483 	  } else {

   484 	  	$isSecureWidget = 0;

   485 	  }

   486 

   487     if( $w3c_widget )

   488     { 

   489       if( $widgetdata->{'MainHTML'} )

   490         {

   491         $startsrc = $widgetdata->{'MainHTML'};

   492         }

   493       else

   494         {

   495         $startsrc = 'index.html';

   496         }

   497       if( $widgetdata->{'IconPath'} )

   498         {

   499         $iconsrc = $widgetdata->{'IconPath'};

   500         }

   501       else

   502         {

   503         $iconsrc = 'icon.png';   

   504         }

   505         

   506   		if($non_nokia_widget)

   507   		{

   508   			$widgetdata->{'ProcessUid'} = CWRT_WIDGET_UI_NON_NOKIA_UID;

   509   		}

   510   		else

   511   		{

   512       		$widgetdata->{'ProcessUid'} = CWRT_WIDGET_UI_UID;

   513       	}

   514       

   515       $widgetdata->{'MimeType'} = "application/widget";

   516     }         

   517 

   518     print "Identifier: $widgetdata->{'BundleIdentifier'}\n" if $self->{args}->{'verbose'};

   519     

   520     # Set widget package properties

   521     $widgetdata->{'FileName'} = $filename;

   522     $widgetdata->{'FileSize'} = $size;

   523 

   524     # Load the language translations for BundleDisplayName

   525     if ($self->{'args'}->{'l10n'})

   526       {

   527       my $localised = $self->getLocalisedStringByLangCode(catfile($tempdir, $root), 'DisplayName', $self->{'args'}->{'l10n'});

   528       $widgetdata->{'BundleDisplayName'} = $localised if $localised;

   529       }

   530     else

   531       {

   532       $widgetdata->{'LocBundleDisplayName'} = $self->getLocalisedStrings(catfile($tempdir, $root), 'DisplayName');

   533       }

   534 

   535     # Fix up some of the fields

   536     $widgetdata->{'BundleName'} = $widgetdata->{'BundleDisplayName'} if !$widgetdata->{'BundleName'};

   537     $widgetdata->{'AllowNetworkAccess'} = $widgetdata->{'AllowFullAccess'} if !$widgetdata->{'AllowNetworkAccess'};

   538     $widgetdata->{'DriveName'} = $drive;

   539     

   540     if( $w3c_widget )

   541       {

   542       $widgetdata->{'PropertyListVersion'} = 4;

   543       my $widget_uid;

   544       

   545       if($non_nokia_widget)

   546   		{

   547   			$widget_uid = CWRT_WIDGET_UI_NON_NOKIA_UID;

   548   		}

   549   		else

   550   		{

   551       	$widget_uid = CWRT_WIDGET_UI_UID;

   552       }

   553       

   554       if($isSharedLibrary)

   555       {

   556         #In case of NOKIA:sharedlibrary, the extracted widget contents and data source are stored under private\<uid>\..\lib\<sharedfoldername>\

   557         $widgetdata->{'BasePath'} = sprintf('%s\\private\\%08X\\%s\\%s\\%s\\', $widgetdata->{'DriveName'}, $widget_uid, "widgets_21D_4C7","lib",$sharedFolderName);

   558         $widgetdata->{'IconPath'} = sprintf('%s\\private\\%08X\\%s\\%s\\%s\\',$widgetdata->{'DriveName'}, $widget_uid, "data" ,"lib" ,$sharedFolderName);

   559       }

   560       else

   561       {

   562         $widgetdata->{'BasePath'} = sprintf('%s\\private\\%08X\\%s\\%s\\', $widgetdata->{'DriveName'}, $widget_uid, "widgets_21D_4C7", hashpjw($widgetdata->{'BundleIdentifier'}));

   563         $widgetdata->{'IconPath'} = sprintf('%s\\private\\%08X\\%s\\%s\\',$widgetdata->{'DriveName'}, $widget_uid, "data" , hashpjw($widgetdata->{'BundleIdentifier'}));

   564       }

   565       $widgetdata->{'MainHTML'} = "$widgetdata->{'BasePath'}$startsrc";

   566       $widgetdata->{'AllowNetworkAccess'} = 1;

   567       

   568       }

   569     else

   570       {

   571       $widgetdata->{'PropertyListVersion'} = 1;

   572       $widgetdata->{'BasePath'} = sprintf('%s\\private\\%08x\\%s\\', $widgetdata->{'DriveName'}, WIDGET_UI_UID, $widgetdata->{'BundleIdentifier'});

   573       $widgetdata->{'MainHTML'} = "$widgetdata->{'BasePath'}$root\\$widgetdata->{'MainHTML'}";

   574       $widgetdata->{'IconPath'} = "$widgetdata->{'BasePath'}$root\\";

   575       }

   576       

   577     $widgetdata->{'BlanketPermissionGranted'} = 0 if( ! $widgetdata->{'BlanketPermissionGranted'} );

   578     $widgetdata->{'MiniViewEnabled'} = 0  if( ! $widgetdata->{'MiniViewEnabled'} );

   579     

   580     # Indicate that the widget was pre-installed

   581     $widgetdata->{'PreInstalled'} = 1;

   582     

   583     # Set BlanketPermissionGranted flag if Widget is listed as a homescreen widget in the INI file

   584     # Error if MiniViewEnabled isn't set

   585     if ($self->{'homescreen'}{lc $filename})

   586       {

   587       $widgetdata->{'BlanketPermissionGranted'} = 1;

   588       die "ERROR: $filename - MiniViewEnabled not set for homescreen widget" if !$widgetdata->{'MiniViewEnabled'};

   589       }

   590 

   591     # Defining UID  

   592     if($self->{'staticUID'}{lc $filename})

   593       {

   594       print "Using Static UID from INI file\n";

   595       $widgetdata->{'Uid'} = $self->{'staticUID'}{lc $filename};

   596       }

   597     else

   598       {

   599       # Find the next free UID to use

   600       $widgetdata->{'Uid'} = $self->findfreeUid($widgetdata);

   601       }

   602     print sprintf("Using UID for midlet: 0x%08X\n", $widgetdata->{'Uid'}) if $self->{args}->{'verbose'};

   603 

   604     # Make sure the destination exists

   605     my $dest = $self->regFileName($drive);

   606     mkpath $dest;

   607 

   608     my $icon;

   609     if($w3c_widget)

   610     {

   611       my $locate = $self->{'args'}->{'l10n'};

   612       my $seperator ='-';

   613       my $position = -1;

   614       my $found = 0 ;

   615       if ($self->{'args'}->{'l10n'})

   616           {

   617             do

   618                {

   619                 my $searchdir = '.\\'.$tempdir.'\\locales\\'.$locate;

   620                 if( opendir(DIR, $searchdir))

   621                     {

   622                     my @files = grep(/$iconsrc$/,readdir(DIR));

   623                     closedir(DIR);

   624                     if(@files)

   625                        {

   626                         $iconsrc = 'locales\\'.$locate.'\\'.$iconsrc ;

   627                         $found = 1;

   628                        }

   629                     }  

   630                 if(($position = rindex($locate,$seperator)) > 0 )

   631                     {

   632                     $locate = substr($locate,0,$position);

   633                     }

   634                } while (!$found && $position > 0);

   635           }

   636           if ($iconsrc)

   637           {

   638             $icon = catfile($tempdir, $root, $iconsrc);    

   639           }

   640             

   641           if(-e $icon)

   642           {

   643              $widgetdata->{'DBIconPath'}= "$widgetdata->{'BasePath'}$iconsrc";

   644              print "Icon found -- $widgetdata->{'DBIconPath'} \n";

   645           }

   646           else

   647           {

   648               $icon = findCmd('default_widget_icon.png');

   649               print "default_widget_icon.png used \n";    

   650               $widgetdata->{'DBIconPath'}= ":/resource/default_widget_icon.png";

   651           }

   652       }

   653     else

   654     {

   655       $icon = catfile($tempdir, $root, 'Icon.png');

   656             die "ERROR: Widget bundle must include an Icon.png file in $root directory.\n" unless -e $icon;

   657     }

   658     

   659     # Create the MBM file icon - in case of sharedlibrary, create only if NOKIA:widget is true

   660     my $mbm;

   661     

   662     print("\nIs shared library - $isSharedLibrary \nIs sharedlib widget - $isSharedWidget \nIs Secure WGZ - $self->{'secure'}{lc $filename}\n");

   663     

   664 		if( ((!$isSharedLibrary) || ($isSharedLibrary && $isSharedWidget)) && (!$self->{'secure'}{lc $filename}))

   665     {

   666     	  print "Creating mbm !!!\n";

   667         die "ERROR: Can't find PNG2MBM command in PATH." if !(my $cmd = findCmd('png2mbm.exe'));

   668         $mbm = $self->regFileName($drive, sprintf("[%08x].mbm", $widgetdata->{'Uid'}));

   669         print "Generating: $mbm\n";

   670                     die "Failed to create MBM $mbm " if system("$cmd $self->{args}->{'verbose'} -in \"$icon\" -out $mbm -sizes ".ICON_SIZES) != 0;

   671     

   672         # Add the mbm to the list of files

   673         $self->addToRomList($drive, $mbm);

   674     

   675         # Create the INI file which defines the registry info

   676         my $ini = catfile($tempdir, 'reg.ini');

   677         $self->makeIni($widgetdata, $ini);

   678         unlink 'debug.ini'; copy($ini, 'debug.ini') if $debug;

   679         print "Generated INI file: $ini\n" if $self->{args}->{'verbose'};

   680     

   681         # Generate the registry files

   682         die "ERROR: Can't find WidgetRegFiles.exe command in PATH." if !($cmd = findCmd('WidgetRegFiles.exe'));

   683         die "Failed to generate registry files" if system("$cmd $ini") != 0;

   684         my ( $reg, $loc ) = ( catfile($dest, sprintf("%08x_reg.rsc", $widgetdata->{'Uid'})), catfile($dest, sprintf("%08x_loc.rsc", $widgetdata->{'Uid'})) );

   685         die "Failed to generate REG file: $!" if !-e $reg;

   686         $self->addToRomList($drive, $reg);

   687         die "Failed to generate LOC file: $!" if !-e $loc;

   688         if ($self->{'args'}->{'l10n'})

   689           {

   690               $self->addToRomList($drive, $loc);

   691           }

   692         else

   693           {

   694               $self->addToRomList($drive, $loc, 'localised');

   695           }

   696         }

   697         

   698     # Create install folder

   699     my $dir = $self->installDir($drive, $widgetdata->{'BundleIdentifier'});

   700     mkpath $dir;

   701 

   702     # Now copy the widget files to the right place

   703     print "Install Directory: $dir\n";

   704     foreach my $widgetfile ( @$extracted )

   705     {

   706       my ( $sourceFile, $destFile ) = ( catfile($tempdir, $widgetfile), catfile($dir, $widgetfile) );

   707       print "Copying $sourceFile to $destFile\n" if $self->{args}->{'debug'};

   708 

   709       # Create the directory if it doesn't exist already

   710       my $dir = dirname($destFile);

   711       if (!-d $dir)

   712         {

   713         mkpath ($dir) or die "Failed to create $dir $!";

   714         }

   715       unlink $destFile;

   716       if (!copy($sourceFile, $destFile))

   717         {

   718         warn "WARNING: Failed to copy $sourceFile to $destFile: $!";

   719         }

   720       #else

   721         {

   722         $self->addToRomList($drive, $destFile);

   723         }

   724     }

   725 

   726     # Copy the MBM file into the widget install directory

   727     # because native installation does and uses it after

   728     # installation to manage UID consistency.

   729     if( (!$isSharedLibrary) || ($isSharedLibrary && $isSharedWidget))

   730     {

   731         my $mbmName = sprintf("[%08x].mbm", $widgetdata->{'Uid'});

   732         my $destFile;

   733         if($w3c_widget)

   734         {

   735             my $dataDir;

   736             

   737             my $widget_uid;

   738       

   739 			      if($non_nokia_widget)

   740 			  		{

   741 			  			$widget_uid = CWRT_WIDGET_UI_NON_NOKIA_UID;

   742 			  		}

   743 			  		else

   744 			  		{

   745 			      	$widget_uid = CWRT_WIDGET_UI_UID;

   746 			      }

   747             

   748             # NOKIA:sharedlibrary check

   749             if($isSharedWidget)

   750             {

   751                 $dataDir = fixFilename(catfile($self->destLocation($drive), 'private', sprintf("%08X", $widget_uid),"data","lib",$sharedFolderName));

   752             }

   753             else

   754             {

   755                 #in case of WGT copy .mbm to \epoc32\winscw\C\private\200267c0\data\hash<BundleId>\

   756                 $dataDir = fixFilename(catfile($self->destLocation($drive), 'private', sprintf("%08X", $widget_uid),"data", $hashval));

   757             }

   758             mkpath $dataDir;

   759             $destFile = catfile($dataDir,$mbmName);

   760         }

   761         else

   762         {

   763            $destFile = catfile($dir, $root, $mbmName);

   764         }

   765     		# Exclude securewidget from making a mbm file

   766 			if (!$self->{'secure'}{lc $filename}){

   767             print "Copying $mbm to $destFile\n" if $self->{args}->{'debug'};

   768             copy $mbm, $destFile or die "Failed to copy $mbm to $destFile: $!";

   769             $self->addToRomList($drive, $destFile);

   770           	}

   771         }

   772         

   773     # Remember the data for the registry

   774     if( $w3c_widget )

   775       {

   776       push @installedCWRTProps, $widgetdata;

   777       }

   778     else

   779       {

   780 	    if (!$self->{'secure'}{lc $filename}){

   781       		push @installedProps, $widgetdata;

   782       	}

   783       }

   784 

   785     if (!$debug)

   786       {

   787       # Perl v5.6 can't delete files with unicode in their name on Windows

   788       if ($] < 5.008 && $^O =~ /MSWin32/)

   789         {

   790         system("rmdir /s /q $tempdir");

   791         }

   792       else

   793         {

   794         rmtree $tempdir;

   795         }

   796       }

   797     #Generate the secsession for .wgt widgets

   798     if( $w3c_widget ) 

   799       {

   800       $self->addToRomList($drive, $self->makeSecSession($drive));

   801       }

   802   }

   803 

   804   my $cwrtdbPath = catfile($self->destLocation($drive), CWRT_WEBAPP_REGISTRY);

   805   $self->addToRomList($drive, $cwrtdbPath);

   806   

   807   # Generate the registry and IBY file

   808   $self->addToRomList($drive, $self->makeRegistry($drive, \@installedProps, 0));

   809   $self->addToRomList($drive, $self->makeRegistry($drive, \@installedCWRTProps, 1));

   810     

   811 

   812   print "\n\n %%%%%          WIDGET PRE-INSTALLATION completed for Drive $drive          %%%%% \n\n";

   813   }

   814 

   815 sub un7zipWidget

   816   {

   817   my ( $self, $filename, $tempdir ) = @_;

   818 

   819   # Unzip the file

   820   die "Can't find 7z.exe tool on PATH." if !findCmd('7z.exe');

   821   die "Failed to extract widget contents using 7zip: $!" if (system("7z x -aoa -o$tempdir \"$filename\" >nul 2>&1") != 0);

   822   }

   823 

   824 sub unzipWidget

   825   {

   826   my ( $self, $filename, $tempdir ) = @_;

   827 

   828   # Unzip the file

   829   die "Can't find unzip.exe tool on PATH." if !findCmd('unzip.exe');

   830   die "Failed to extract widget contents using zip: $!" if (system("unzip.exe \"$filename\" -d $tempdir >nul 2>&1") != 0);

   831   }

   832 

   833 # Recursively get list of files in a folder

   834 sub getFiles

   835   {

   836   my ( $self, $tempdir ) = @_;

   837 

   838   my $root = '.';

   839   my @extracted;

   840   my $size =0;

   841   

   842   my @dirs = '.';

   843   foreach my $dir ( @dirs )

   844     {

   845     opendir DIR, catfile($tempdir, $dir) or die "Failed to opendir $dir: $!";

   846     foreach ( grep !/^\.{1,2}$/, readdir DIR )

   847       {

   848       my $name = catfile($dir, $_);

   849       my $fullname = catfile($tempdir, $name);

   850       if (-d $fullname)

   851         {

   852         push @dirs, $name;

   853         }

   854       else

   855         {

   856         # Remember total size for later

   857         if (-e $fullname)

   858           {

   859           push @extracted, $name;

   860           print "Extracted: $name\n" if $self->{args}->{'debug'};

   861           $size += -s $fullname;

   862 

   863           # Get root

   864           if ($name =~ /info.plist$/i && $name =~ /^([^\/\\]+)[\/\\]/)

   865             {

   866             $root = $1;

   867             }

   868           }

   869         else

   870           {

   871           warn "WARNING: Failed to find extracted file $fullname";

   872           }

   873         }

   874       }

   875     closedir DIR;

   876     }

   877 

   878   return ( $root, \@extracted, $size );

   879   }

   880 

   881 ## see http://www.loc.gov/standards/iso639-2/php/code_list.php

   882 ## see http://www.loc.gov/standards/iso639-2/faq.html#2

   883 sub getLocalisedStringByLangCode

   884   {

   885   my ( $self, $dir, $strName, $langCode ) = @_;

   886   my $localised;

   887 

   888   # Generate the name of the file containing localised strings for this language

   889   my $locfile = catfile($dir, "$langCode.lproj", "InfoPlist.strings");

   890   if (-e $locfile)

   891         {

   892     # Open the file

   893     print "Found $langCode language translations in $locfile\n" if $verbose;

   894     open LOC, $locfile or die "Failed to open $locfile: $!";

   895 

   896     # Get the byte order mark from the start of the file

   897     my $bom;

   898     $bom = unpack("S", $bom) if (read(LOC, $bom, 2) == 2);

   899     if ($bom)

   900       {

   901       if ($bom == 0xEFBB)

   902         {

   903         # Skip utf8 bom

   904         seek LOC, 3, 0;

   905         }

   906       elsif ($bom != 0xFFFE && $bom != 0xFEFF)

   907         {

   908         seek LOC, 0, 0;

   909         undef $bom;

   910         }

   911       }

   912     else

   913       {

   914       # go back to start of file if no bom

   915       seek LOC, 0, 0;

   916       undef $bom;

   917       }

   918 

   919     while(my $line = <LOC>)

   920       {

   921       # Do unicode conversion

   922       my $ustr;

   923       if ($bom)

   924         {

   925         $ustr = utf16($line);

   926         $ustr->byteswap if $bom != 0xFFFE;

   927         }

   928       else

   929         {

   930         $ustr = utf8($line);

   931         }

   932 

   933       # Find the string we're looking for

   934       if ($ustr->utf8 =~ /(?:^|\s)$strName\s*=\s*\"([^\"]*)\"/)

   935         {

   936         print "\t...$strName => $1\n" if $debug;

   937         $localised = utf8($1);

   938         }

   939       }

   940     close LOC;

   941     }

   942     return $localised;

   943   }

   944 

   945 # Get localised version of strings if they exist

   946 sub getLocalisedStrings

   947   {

   948   my ( $self, $dir, $strName ) = @_;

   949   return if (!$self->{'langmapping'});

   950 

   951   # Iterate through all the languages we know about

   952   my %result;

   953   for(my $i = 0; $i < scalar(@{ $self->{'langmapping'}->{LangID} }); $i++)

   954     {

   955     my ( $langid, $langname ) = ( $self->{'langmapping'}->{LangID}->[$i], $self->{'langmapping'}->{LangDir}->[$i] );

   956 

   957     my $localised = $self->getLocalisedStringByLangCode($dir, $strName, $langname);

   958     $result{$langid} = $localised if $localised;

   959     }

   960 

   961   return \%result if keys %result;

   962   }

   963 

   964 # Find and execute a command

   965 sub findCmd

   966   {

   967   my $cmd = shift;

   968   return fixFilename("./$cmd") if -e $cmd;

   969 

   970   # PATH separator differs on Windows and Linux

   971   my $sep = $^O =~ /MSWin32/ ? ';' : ':';

   972 

   973   # Search each entry in the PATH

   974   my @paths = split /$sep/, $ENV{PATH};

   975   push @paths, dirname($0);

   976   foreach my $path ( @paths )

   977     {

   978     my $fullcmd = fixFilename(catfile($path, $cmd));

   979     return $fullcmd if -e $fullcmd;

   980     }

   981   }

   982 

   983 # Make INI file describing widget - this is passed to widgetregfiles.exe

   984 sub makeIni

   985   {

   986   my ( $self, $data, $file ) = @_;

   987   open INI, ">$file" or die "Failed to open $file for writing: $!";

   988   binmode INI, ":utf8" if $] >= 5.008;

   989 

   990   # Get directory where mbm should go

   991   my $dir = $self->regFileName($data->{'DriveName'});

   992 

   993   print INI "[app_registration_info]\n";

   994   print INI sprintf("uid=%08x\n", $data->{'Uid'});

   995   print INI "app_file=$data->{'MainHTML'}\n";

   996   print INI "caption=$data->{'BundleDisplayName'}\n";

   997   print INI "drive_name=$data->{'DriveName'}\n";

   998   print INI "results_dir=$dir\n";

   999   

  1000   if( $w3c_widget )

  1001   {

  1002     print INI "app_type=200267DC\n";

  1003     print " WGT Widget:: app_type added to ini of widgetregfiles.exe \n" if $debug;

  1004   }

  1005   

  1006 

  1007   # Add language stuff if we have the mapping

  1008   if ($data->{'LocBundleDisplayName'})

  1009     {

  1010     my @langList;

  1011     foreach my $langid ( sort { $a <=> $b } keys %{ $data->{'LocBundleDisplayName'} } )

  1012       {

  1013       my $symid = sprintf("%02d", $langid);

  1014       push @langList, $symid;

  1015       print INI "caption$symid=", $data->{'LocBundleDisplayName'}->{$langid}->utf8, "\n";

  1016       }

  1017     print INI "languages=", join(' ', @langList), "\n";

  1018     }

  1019 

  1020   close INI;

  1021   convert2Unicode($file);

  1022   }

  1023 

  1024  sub findfreeUid

  1025   {

  1026   my ( $self, $data ) = @_;

  1027   my $appfile = lc $data->{'MainHTML'};

  1028   my $uid;

  1029   my $size;

  1030     if($w3c_widget)     #CWRT Widget

  1031     {

  1032       # pick the next free CWRT Internal UID

  1033       if(isInternal($data->{'DriveName'}))

  1034       {

  1035         print "\nInternal CWRT UID";

  1036         $size = scalar @staticUidCwrtIntList;

  1037         print " Static UID :: @staticUidCwrtIntList Length -- $size \n" if($size);

  1038         for(my $i=0; $i<$size; $i++)

  1039         {

  1040 		  #skip looping if freeUid found

  1041           if( $self->{'freeuidcwrtint'} lt $staticUidCwrtIntList[$i] ) {last};

  1042           

  1043           if($self->{'freeuidcwrtint'} == $staticUidCwrtIntList[$i]) 

  1044           { 

  1045             $self->{'freeuidcwrtint'}++; 

  1046           }

  1047         }

  1048         $uid = $self->{'freeuidcwrtint'}++;   # Assign and then set next free UID

  1049       } 

  1050       else

  1051       {

  1052         # pick the next free CWRT External UID

  1053         print "\nExternal CWRT UID ";

  1054         $size = scalar @staticUidCwrtExtList;

  1055         print "Static UID :: @staticUidCwrtExtList Length -- $size \n";

  1056         

  1057         for(my $i=0; $i<$size; $i++)

  1058         {

  1059           if( $self->{'freeuidcwrtext'} lt $staticUidCwrtExtList[$i] ) {last};

  1060           

  1061           if($self->{'freeuidcwrtext'} == $staticUidCwrtExtList[$i]) 

  1062           { 

  1063             $self->{'freeuidcwrtext'}++; 

  1064           }

  1065         }

  1066         $uid = $self->{'freeuidcwrtext'}++;   # Assign and then set next free UID

  1067       }

  1068     }

  1069     else      #WRT widget

  1070     {

  1071       # pick the next free WRT Internal UID

  1072       if(isInternal($data->{'DriveName'}))

  1073       {

  1074         # pick the next free CWRT Internal UID

  1075         if(isInternal($data->{'DriveName'}))

  1076         {

  1077           print "\nInternal WRT UID ";

  1078           $size = scalar @staticUidWrtIntList;

  1079           print " STATIC UID :: @staticUidWrtIntList Length -- $size\n";

  1080                  

  1081           for(my $i=0; $i<$size; $i++)

  1082           {

  1083             if( $self->{'freeuidwrtint'} lt $staticUidWrtIntList[$i] ) {last};

  1084             

  1085             if($self->{'freeuidwrtint'} == $staticUidWrtIntList[$i]) 

  1086             { 

  1087               $self->{'freeuidwrtint'}++; 

  1088             }

  1089           }

  1090           $uid = $self->{'freeuidwrtint'}++;   # Assign and then set next free UID

  1091         }

  1092       }

  1093       else

  1094       {

  1095         # pick the next free WRT External UID

  1096         print "\nExternal WRT UID ";

  1097         $size = scalar @staticUidWrtExtList;

  1098         print "STATIC UID :: @staticUidWrtExtList Length -- $size\n";

  1099         

  1100         for(my $i=0; $i<$size; $i++)

  1101         {

  1102           if( $self->{'freeuidwrtext'} lt $staticUidWrtExtList[$i] ) {last};

  1103           

  1104           if($self->{'freeuidwrtext'} == $staticUidWrtExtList[$i]) 

  1105           { 

  1106             $self->{'freeuidwrtext'}++; 

  1107           }

  1108         }

  1109         $uid = $self->{'freeuidwrtext'}++;   # Assign and then set next free UID

  1110       }

  1111     }

  1112   print sprintf("Generated UID: hex->0x%08X dec->$uid\n \n",$uid);

  1113   return $uid;

  1114   }

  1115 

  1116 # Fix slash problems in a filename

  1117 sub fixFilename

  1118   {

  1119   my $filename = shift;

  1120   $filename =~ s/([\\\/])[\\\/]/$1/g;

  1121   return catfile(split(/[\\\/]/, $filename));

  1122   }

  1123 

  1124 # Get install location

  1125 sub destLocation

  1126   {

  1127   my ( $self, $drive ) = @_;

  1128   my $letter = uc(substr($drive, 0, 1));

  1129   

  1130   # Was any destination location specified in the config file?

  1131   if ($self->{destination} && $self->{destination}->{$letter})

  1132     {

  1133     return catfile($self->{'args'}->{'epocroot'}, $self->{destination}->{$letter});

  1134     }