// Copyright (c) 2001-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:
//
#include <ecom/implementationproxy.h>
#include <cntdb.h>
#include "cntphone.h"
/*
This is the specification for the implementation of the phone number parser.
This has been provided by Pekka Jokela (Nokia).
1. If the first character of the number is '+', the '+' character is
left out, and the real phone number is considered to begin right after
that.
* If there is a '(' as the first character and the plus sign follows then
i.e. first two characters = '(+' then they must both be removed and the
real phone number is considered to begin after them
2. If the number begins with a '*' or '#' symbol, all characters to
the last '*' or '#' symbol are ignored, and the real phone number is
considered to begin right after that.
* If there is '+' character right after the last '#' or '*', the '+'
character is left out, and the real phone number is considered to
begin after that.
* If there is '+' character within first five characters, all
characters to the '+' symbol are ignored, and the real phone number is
considered to begin right after that.
3. If the number contains special characters 'p',' w' and '+' , all
characters after the first special character are ignored.
If the number contains '*' and '#' symbols, i.e. there is a
supplementary service code or a feature code within the number:
* If the code is finished by '*' or by '# the real phone number can
be separated easily (refer to the table below, example 1). Even
possible '+' symbol after the code can be left out (example 2).
* If the code is finished by a digit, the real phone number can not be
separated from the code. In most cases, this is not a problem, because
only seven last digits are significant for comparison (example 3). If
there is '+' symbol between the code and the real phone number, the
'+' has to be within first five characters or otherwise it is
considered to start a DTMF function. (example 4)
These all match 9461235:
*#020# 79461235: p123
*#020# +79461235: p123
*020 79461235:
*020 +79461235:
+79461235: +3
+79461235: p123
(+020) 79461235:
And these something else:
*#020# 79461235:#p123 -> empty
*12345+79461235: -> 12345
*+123+456+++++++++++ ->123
The relevant ETSI specifications are:
ETSI 02.07 - MS Features. Section B.3.4.
ETSI 03.14 - Defines what DTMF digits are.
ETSI 11.11 - Section 10.5.1. Defines the Separator digit.
*/
const TInt KPlusWithinChars = 5;
const TText KSymbolPause = 'p';
const TText KSymbolWait = 'w';
const TText KSymbolPlus = '+';
const TText KSymbolAsterisk = '*';
const TText KSymbolHash = '#';
//const symbol for checking the opening bracket before a plus
const TText KSymbolOpenBrace = '(';
/**
* Extracts the real phone number from a contacts phone number field.
* This method strips away any DTMF strings or extended services. An empty
* descriptor is returned in aRawNumber if the field doesn't have a valid phone
* number.
*
* @param aTextualNumber Descriptor containing a contacts model phone number field
* @param aRawNumber Descriptor to write the raw number to (loaned by caller)
*/
void CContactDefaultPhoneNumberParser::ExtractRawNumber(const TDesC& aTextualNumber, TDes& aRawNumber)
{
aRawNumber.Zero();
TInt length = aTextualNumber.Length();
if (length==0)
{
return;
}
TPtrC numberPtr( aTextualNumber );
TUint firstChar = numberPtr[0];
//gobble spaces
while (TChar(firstChar).IsSpace())
{
--length;
if (length==0)
{
return;
}
numberPtr.Set(numberPtr.Right(length));
firstChar = numberPtr[0];
}
// Get left hand side
if ( firstChar == KSymbolAsterisk || firstChar == KSymbolHash )
{
//Check if there is plus on first five chars:
TInt newStartPlace = numberPtr.Locate( KSymbolPlus );
if ( newStartPlace>=KPlusWithinChars || newStartPlace==KErrNotFound )
{
// There is always star or hash...
newStartPlace = Max( numberPtr.LocateReverse(KSymbolAsterisk ) ,numberPtr.LocateReverse( KSymbolHash) );
}
length = length - newStartPlace -1;
if ( length <= 0 )
{
return;
}
numberPtr.Set( numberPtr.Right( length ) );
firstChar = numberPtr[0];
}
//test condition to satisfy the removal of '(' the next if
//statement removes the '+' if needed
if ( firstChar == KSymbolOpenBrace )
{
length--;
numberPtr.Set( numberPtr.Right( length ) );
// This may be the only character in the descriptor so only access if
// 1 or more characters left.
if (length > 0 )
{
firstChar = numberPtr[0];
}
}
if ( firstChar == KSymbolPlus )
{
length--;
numberPtr.Set( numberPtr.Right( length ) );
}
if (length==0)
{
return;
}
// Find right hand side
TLex numberLexer( numberPtr );
for ( ; ; )
{
TChar nextChar = numberLexer.Peek();
if ( !nextChar )
{
break;
}
if ( nextChar.IsDigit() )
{
aRawNumber.Append( nextChar );
numberLexer.Inc();
}
else if ( nextChar == KSymbolAsterisk || nextChar == KSymbolHash )
{
aRawNumber.Zero();
return;
}
else
{
nextChar.LowerCase();
if ( nextChar == KSymbolPause
|| nextChar == KSymbolWait
|| nextChar == KSymbolPlus)
{
break;
}
numberLexer.Inc();
}
}
}
CContactDefaultPhoneNumberParser* CContactDefaultPhoneNumberParser::NewL()
{
CContactDefaultPhoneNumberParser* self = new (ELeave) CContactDefaultPhoneNumberParser(); // calls c'tor
return self;
}
// Export the implementation collection function
const TImplementationProxy ImplementationTable[] =
{
IMPLEMENTATION_PROXY_ENTRY(0x102035FC, CContactDefaultPhoneNumberParser::NewL)
};
EXPORT_C const TImplementationProxy* ImplementationGroupProxy(TInt& aTableCount)
{
aTableCount = sizeof(ImplementationTable) / sizeof(TImplementationProxy);
return ImplementationTable;
}
/**
* Standard Epoc32 Dll Entry point
*/