/*
* Copyright (c) 2008 - 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: javamobinfo implementation
*
*/
#include <e32base.h>
#include <etelmm.h>
#include <mmtsy_names.h> // TSY and Phone name
#include <commsdattypesv1_1.h>
#include <cdblen.h>
#include <commdb.h>
#include <rconnmon.h>
#include <CoreApplicationUIsSDKCRKeys.h>
#include <etel3rdparty.h>
#include <cmmanager.h>
#include <cmconnectionmethoddef.h>
#include <cmpluginpacketdatadef.h>
#include <cmpluginwlandef.h>
#include <cmpluginhscsddef.h>
#include "connectionmanager.h"
using namespace CMManager;
#ifndef SYMBIAN_ENABLE_SPLIT_HEADERS
#include <es_sock.h>
#include <es_enum.h>
#else
#include <es_enum_internal.h>
#include <es_sock_partner.h>
#endif
#include "logger.h"
#include "s60commonutils.h"
#include "com_nokia_mj_impl_properties_mobinfo_MobileInfoProperties.h"
#include "mobinfoconstants.h"
#include "javauids.h"
using namespace std;
using namespace CommsDat;
_LIT(KNetworkAvailable, "available");
_LIT(KNetworkUnavailable, "unavailable");
_LIT(KNetworkAccessPdLAN, "lan"); // Local Area Network
_LIT(KNetworkAccessPdGSM, "pd"); // Packet data in GSM network
_LIT(KNetworkAccessPdEDGE, "pd.EDGE"); // Packet data in EDGE network
_LIT(KNetworkAccessPd3G, "pd.3G"); // Packet data in 3G network
_LIT(KNetworkAccessHSPDA, "pd.HSPDA"); // High speed downlink packet access for 3G networks
_LIT(KNetworkAccessCSD, "csd"); // Circuit switched data, for example GSM CSD/HSCSD data call
_LIT(KNetworkAccessBtPan, "bt_pan"); // Bluetooth PAN network
_LIT(KNetworkAccessWLAN, "wlan"); // Wireless network, for example 802.11b, 802.11G or WiMaX
_LIT(KNetworkAccessNa, "na"); // Not applicable, the implementation can’t determine the type
_LIT(KNetworkStatusHome, "home"); // Home operator
_LIT(KNetworkStatusRoaming, "roaming"); // Roaming
_LIT(KNetworkStatusUnknown, "unknown"); // Unknown operator
_LIT(KMSISDNSeparator, " "); // separator MSISDN numbers
_LIT(KNameNotAvailable, "");
const TInt KMaxPropertySize = 50;
const TInt KJVMProcessUid = KJavaMidp;
// ---------------------------------------------------------------------------
// forward declarations
// ---------------------------------------------------------------------------
HBufC* GetProperty(const TInt aProperty, const TUint32 aAppDefaultApn, const TUint32 aAppDefaultApType);
HBufC* GetTelephonyPropertyL(const TInt aProperty);
HBufC* GetDateTimePropertyL(const TInt aProperty);
HBufC* GetNetworkAccessL(const TUint32 aAppDefaultApn, const TUint32 aAppDefaultApType);
TUint32 GetUsedIapL();
HBufC* GetBearerTypeL(TUint32 aIapId);
HBufC* GetIapBearerTypeL(const TUint32 aAppDefaultApn, const TUint32 aAppDefaultApType);
HBufC* TranslateBearerInfoToNetworkAccessL(TConnMonBearerInfo aBearerInfo);
HBufC* GetAppDefIapBearerTypeL(const TUint32 aAppDefaultApn);
/*
* Class: com_nokia_mj_impl_properties_mobinfo_MobileInfoProperties
* Method: _getProperty
* Signature: (I)Ljava/lang/String;
*/
// ---------------------------------------------------------------------------
// JNI function called from java side from MobileInfoProperties class.
// Each mobinfo java property implementation calls the getPropertyMsid()
// function of the MobileInfoProperties class.
// @param aProperty name of the actual property
// @param aAppDefaultApn application default access point id
// @param aAppDefaultApType application default access point type ( SNAP, IAP)
// @param aAppDefaultApn Application default apn
// -----------------------------------------------------------------------------
JNIEXPORT jstring JNICALL
Java_com_nokia_mj_impl_properties_mobinfo_MobileInfoProperties__1getPropertyApn
(JNIEnv* aJni, jclass, jint aProperty, jint aAppDefaultApn, jint aAppDefaultApType)
{
LOG1(ESOCKET, EInfo, "MOBINFO + getPropertyMsid(), msid: %D", aAppDefaultApn);
HBufC* property = NULL;
jstring str = NULL;
property = GetProperty(aProperty, aAppDefaultApn,aAppDefaultApType);
if (NULL != property)
{
LOG(ESOCKET,EInfo,"_getPropertyApn, property is not null");
str = java::util::S60CommonUtils::NativeToJavaString(*aJni, property->Des());
LOG(ESOCKET, EInfo,"MOBINFO - after nativetojavastring");
//LOG1( ESOCKET, EInfo,"MOBINFO returning value: %S", property->Des());
delete property;
}
LOG(ESOCKET, EInfo, "MOBINFO - getPropertyMsid()");
return str;
}
JNIEXPORT jstring JNICALL Java_com_nokia_mj_impl_properties_mobinfo_MobileInfoProperties__1getProperty
(JNIEnv *aJni, jobject, jint aKey)
{
LOG1(ESOCKET, EInfo, "MOBINFO Key: %d", aKey);
HBufC* property = NULL;
jstring str = NULL;
property = GetProperty(aKey,NULL,0);
if (NULL != property)
{
TPtrC data(property->Des());
str = java::util::S60CommonUtils::NativeToJavaString(*aJni, data);
delete property;
}
return str;
}
HBufC* GetProperty(const TInt aProperty, const TUint32 aAppDefaultApn, const TUint32 aAppDefaultApType)
{
JELOG2(ESOCKET);
LOG(ESOCKET, EInfo, "MOBINFO + GetProperty()");
HBufC* property = NULL;
TInt err;
switch (aProperty)
{
case DATEFORMAT:
case TIMEFORMAT:
TRAP(err, property = GetDateTimePropertyL(aProperty));
break;
case NETWORK_ACCESS:
TRAP(err, property = GetNetworkAccessL(aAppDefaultApn,aAppDefaultApType));
LOG(ESOCKET, EInfo,"after GetNetworkAccessL");
break;
default:
TRAP(err, property = GetTelephonyPropertyL(aProperty));
break;
}
return property;
}
// ---------------------------------------------------------------------------
// Finds the default TSY module name from the CommDB. The GlobalSettings
// table contains a field: ModemForPhoneServicesAndSMS, this field point to
// a record in the ModemBearer table. The function reads the TsyName from
// this linked table.
// @param aTsyName TSY name to be initialized
// -----------------------------------------------------------------------------
void GetDefaultTSYL(TDes& aTsyName)
{
JELOG2(ESOCKET);
CMDBSession* db = CMDBSession::NewL(KCDVersion1_1);
CleanupStack::PushL(db);
// Load Global Settings record (there is always only 1 record in it)
CCDGlobalSettingsRecord
* ptrSingleGlSettingRecord =
static_cast<CCDGlobalSettingsRecord*>(CCDRecordBase::RecordFactoryL(
KCDTIdGlobalSettingsRecord));
CleanupStack::PushL(ptrSingleGlSettingRecord);
ptrSingleGlSettingRecord->iRecordTag.SetL(1);
if (ptrSingleGlSettingRecord->FindL(*db))
{
// Find record by RecordTag
CCDModemBearerRecord
* ptrModemRecord =
static_cast<CCDModemBearerRecord*>(CCDRecordBase::RecordFactoryL(
KCDTIdModemBearerRecord));
CleanupStack::PushL(ptrModemRecord);
ptrModemRecord->iRecordTag.SetL(
ptrSingleGlSettingRecord->iModemForPhoneServicesAndSMS);
if (ptrModemRecord->FindL(*db))
{
aTsyName.Copy(ptrModemRecord->iTsyName);
}
CleanupStack::PopAndDestroy(ptrModemRecord);
}
CleanupStack::PopAndDestroy(ptrSingleGlSettingRecord);
CleanupStack::PopAndDestroy(db);
}
// ---------------------------------------------------------------------------
// Initializes the given RTelServer with the default TSY (GetDefaultTSYL)
// module and opens the corresponding RMobilePhone. The searching of the
// correct phone is based on the TSY name.
// @param aMobilePhone RMobilePhone to be opened
// @param aTelServer RTelServer instance to be initialized
// -----------------------------------------------------------------------------
void GetDefaultPhoneL(RMobilePhone& aMobilePhone, RTelServer& aTelServer)
{
JELOG2(ESOCKET);
HBufC* tsyName = HBufC16::NewLC(KCommsDbSvrMaxFieldLength);
TPtr tsyPtr(tsyName->Des());
GetDefaultTSYL(tsyPtr);
//LOG1(ESOCKET, EInfo, "MOBINFO Default Tsy = %S", tsyPtr);
User::LeaveIfError(aTelServer.LoadPhoneModule(*tsyName));
LOG(ESOCKET, EInfo, "MOBINFO TSY loaded...");
// Get the name of the first phone
TInt numPhones = 0;
User::LeaveIfError(aTelServer.EnumeratePhones(numPhones));
LOG1(ESOCKET, EInfo, "MOBINFO - Phone count %D", numPhones);
// Iterate through the phones until we find the correct one
while (numPhones > 0)
{
// The GetTsyName function requires the index of the phone
// so we must decrease the number here
--numPhones;
TName phoneTsy;
User::LeaveIfError(aTelServer.GetTsyName(numPhones, phoneTsy));
//LOG1(ESOCKET, EInfo, "MOBINFO Available phone...%S", phoneTsy);
if (phoneTsy.CompareF(*tsyName) == KErrNone)
{
// Get the phone info
RTelServer::TPhoneInfo info;
User::LeaveIfError(aTelServer.GetPhoneInfo(numPhones, info));
//LOG1(ESOCKET, EInfo, "MOBINFO Opening phone...%S", info.iName);
TInt error = aMobilePhone.Open(aTelServer, info.iName);
LOG1(ESOCKET, EInfo, "MOBINFO Phone status %D", error);
User::LeaveIfError(error);
// We can finish the search here
numPhones = 0;
}
}
CleanupStack::PopAndDestroy(tsyName);
}
// ---------------------------------------------------------------------------
// Retrieves the IMEI or IMSI number.
// @param aMobilePhone initialized RMobilePhone instance.
// @param aProperty the name of the actual property
// @return percentage of battery charge level
// -----------------------------------------------------------------------------
HBufC* GetIdentityPropertyL(RMobilePhone& aMobilePhone, const TInt aProperty)
{
JELOG2(ESOCKET);
TUint32 identityCaps = 0;
HBufC* telephonyProperty = NULL;
TRequestStatus status;
LOG(ESOCKET, EInfo, "MOBINFO + GetIdentityPropertyL()");
LOG(ESOCKET, EInfo, "MOBINFO Checking phone identitycaps");
TInt identityStatus = aMobilePhone.GetIdentityCaps(identityCaps);
LOG1(ESOCKET, EInfo, "MOBINFO Checking identity caps status=%D", identityStatus);
if ((identityCaps & RMobilePhone::KCapsGetSubscriberId)
&& (aProperty == IMSI))
{
LOG(ESOCKET, EInfo, "MOBINFO retrieving IMSI");
// initialise a variable to hold IMSI
RMobilePhone::TMobilePhoneSubscriberId imsi;
// put values into variable
aMobilePhone.GetSubscriberId(status, imsi);
User::WaitForRequest(status);
User::LeaveIfError(status.Int());
LOG(ESOCKET, EInfo, "MOBINFO returning property IMSI");
telephonyProperty = imsi.AllocL();
}
if ((identityCaps & RMobilePhone::KCapsGetSerialNumber)
&& (aProperty == IMEI))
{
LOG(ESOCKET, EInfo, "MOBINFO retrieving IMEI");
RMobilePhone::TMobilePhoneIdentityV1 phoneId;
aMobilePhone.GetPhoneId(status, phoneId);
User::WaitForRequest(status);
User::LeaveIfError(status.Int());
LOG(ESOCKET, EInfo, "MOBINFO returning property IMEI");
telephonyProperty = (phoneId.iSerialNumber).AllocL();
}
return telephonyProperty;
}
// ---------------------------------------------------------------------------
// Retrieves the battery charge level in percentage.
// @param aMobilePhone initialized RMobilePhone instance.
// @return percentage of battery charge level
// -----------------------------------------------------------------------------
HBufC* GetBatteryPropertyL(RMobilePhone& aMobilePhone)
{
JELOG2(ESOCKET);
HBufC* telephonyProperty = NULL;
LOG(ESOCKET, EInfo, "MOBINFO + GetBatteryPropertyL()");
// Check BatteryCaps
TUint32 batteryCaps;
LOG(ESOCKET, EInfo, "MOBINFO Checking phone BatteryCaps");
TInt batteryCapsStatus = aMobilePhone.GetBatteryCaps(batteryCaps);
LOG1(ESOCKET, EInfo, "MOBINFO Checking Battery caps status=%D",
batteryCapsStatus);
if (batteryCapsStatus == KErrNone)
{
TRequestStatus status;
LOG(ESOCKET, EInfo, "MOBINFO retrieving battery charge level");
RMobilePhone::TMobilePhoneBatteryInfoV1 info;
aMobilePhone.GetBatteryInfo(status, info);
User::WaitForRequest(status);
User::LeaveIfError(status.Int());
LOG(ESOCKET, EInfo, "MOBINFO returning property Battery charge level");
TBuf<KMaxPropertySize> buf; // percentage of battery charge level
buf.Num(info.iChargeLevel);
telephonyProperty = buf.AllocL();
}
LOG(ESOCKET, EInfo, "MOBINFO - GetBatteryPropertyL()");
return telephonyProperty;
}
// ---------------------------------------------------------------------------
// Retrieves the network related properties.
// @param aMobilePhone initialized RMobilePhone instance.
// @param aProperty name of the actual property
// @return property value
// -----------------------------------------------------------------------------
HBufC* GetNetworkPropertyL(RMobilePhone& aMobilePhone, const TInt aProperty)
{
JELOG2(ESOCKET);
HBufC* telephonyProperty = NULL;
LOG(ESOCKET, EInfo, "MOBINFO + GetNetworkPropertyL()");
if ((aProperty == NETWORK_ID) || (aProperty == COUNTRY_CODE) || (aProperty
== CELLID))
{
// Check NetworkCaps
TUint32 networkCaps;
LOG(ESOCKET, EInfo, "MOBINFO Checking phone NetworkCaps");
TInt networkCapsStatus = aMobilePhone.GetNetworkCaps(networkCaps);
LOG1(ESOCKET, EInfo, "MOBINFO Checking network caps status=%D",
networkCapsStatus);
if (networkCapsStatus == KErrNone)
{
TRequestStatus status;
if ((networkCaps & RMobilePhone::KCapsGetCurrentNetwork)
&& (aProperty == NETWORK_ID))
{
LOG(ESOCKET, EInfo, "MOBINFO retrieving NetworkId");
RMobilePhone::TMobilePhoneOPlmnV3 locInfo;
RMobilePhone::TMobilePhoneOPlmnV3Pckg pckgLocInfo(locInfo);
RMobilePhone::TMobilePhoneNetworkNameV3 networkName;
RMobilePhone::TMobilePhoneNetworkNameV3Pckg pckgNetworkName(
networkName);
aMobilePhone.GetCurrentNetworkName(status, pckgNetworkName,
pckgLocInfo);
User::WaitForRequest(status);
User::LeaveIfError(status.Int());
LOG(ESOCKET, EInfo, "MOBINFO returning property NetworkId");
_LIT(KStringFormat, "%S (%S)");
// 8 is the max length of MNC, + 3 chars needed for the
// formatting chars like space, "(" and ")"
TBuf<KMaxPropertySize + RMobilePhone::KMaxNetworkNameFieldSize>
disp;
disp.Format(KStringFormat, &locInfo.iNetworkId,
&networkName.iShortName);
telephonyProperty = disp.AllocL();
}
else if ((networkCaps & RMobilePhone::KCapsGetCurrentNetwork)
&& (aProperty == CELLID))
{
LOG(ESOCKET, EInfo, "MOBINFO retrieving CellId");
RMobilePhone::TMobilePhoneNetworkInfoV1 networkInfo;
RMobilePhone::TMobilePhoneNetworkInfoV1Pckg networkInfoPckg(
networkInfo);
RMobilePhone::TMobilePhoneLocationAreaV1 locationArea;
aMobilePhone.GetCurrentNetwork(status, networkInfoPckg,
locationArea);
User::WaitForRequest(status);
User::LeaveIfError(status.Int());
LOG(ESOCKET, EInfo, "MOBINFO returning property CellId");
TBuf<KMaxPropertySize> disp;
disp.Num(locationArea.iCellId, EDecimal);
telephonyProperty = disp.AllocL();
}
else // COUNTRY_CODE
{
LOG(ESOCKET, EInfo, "MOBINFO retrieving CountryCode");
RMobilePhone::TMobilePhoneOPlmnV3 locInfo;
RMobilePhone::TMobilePhoneOPlmnV3Pckg pckgLocInfo(locInfo);
RMobilePhone::TMobilePhoneNetworkNameV3 networkName;
RMobilePhone::TMobilePhoneNetworkNameV3Pckg pckgNetworkName(
networkName);
aMobilePhone.GetCurrentNetworkName(status, pckgNetworkName,
pckgLocInfo);
User::WaitForRequest(status);
User::LeaveIfError(status.Int());
LOG(ESOCKET, EInfo, "MOBINFO returning property CountryCode");
telephonyProperty = (locInfo.iCountryCode).AllocL();
}
}
}
else if (aProperty == NETWORK_SIGNAL)
{
// Check Signal related Caps
TUint32 signalCaps;
LOG(ESOCKET, EInfo, "MOBINFO Checking phone SignalCaps");
TInt signalCapsStatus = aMobilePhone.GetSignalCaps(signalCaps);
LOG1(ESOCKET, EInfo, "MOBINFO Checking signal caps status=%D",
signalCapsStatus);
if (signalCapsStatus == KErrNone)
{
TRequestStatus status;
if (signalCaps & RMobilePhone::KCapsGetSignalStrength)
{
LOG(ESOCKET, EInfo, "MOBINFO retrieving SignalStrength");
TInt32 signalStrength;
TInt8 bar;
aMobilePhone.GetSignalStrength(status, signalStrength, bar);
User::WaitForRequest(status);
User::LeaveIfError(status.Int());
LOG(ESOCKET, EInfo,
"MOBINFO returning property SignalStrength");
_LIT(KStringFormat, "%d (%d dBm)");
TBuf<KMaxPropertySize> disp;
disp.Format(KStringFormat, bar, signalStrength);
telephonyProperty = disp.AllocL();
}
}
}
else if (aProperty == NETWORKSTATUS)
{
// Check network status
LOG(ESOCKET, EInfo, "MOBINFO Checking network status");
// Check NetworkCaps
TUint32 networkCaps;
TInt networkCapsStatus = aMobilePhone.GetNetworkCaps(networkCaps);
LOG1(ESOCKET, EInfo, "MOBINFO Checking network caps status=%D",
networkCapsStatus);
if (networkCapsStatus == KErrNone)
{
TRequestStatus status;
RMobilePhone::TMobilePhoneRegistrationStatus networkStatus;
aMobilePhone.GetNetworkRegistrationStatus(status, networkStatus);
User::WaitForRequest(status);
User::LeaveIfError(status.Int());
switch (networkStatus)
{
case RMobilePhone::ERegisteredOnHomeNetwork:
case RMobilePhone::ERegisteredBusy:
telephonyProperty = KNetworkStatusHome().AllocL();
break;
case RMobilePhone::ERegisteredRoaming:
telephonyProperty = KNetworkStatusRoaming().AllocL();
break;
default:
telephonyProperty = KNetworkStatusUnknown().AllocL();
break;
}
}
LOG(ESOCKET, EInfo, "MOBINFO returning property NetworkStatus");
}
else if (aProperty == NETWORK_AVAILABILITY)
{
// Check NetworkAvailability related Caps
TUint32 indCaps;
TUint32 actionCaps;
LOG(ESOCKET, EInfo, "MOBINFO Checking phone IndicatorCaps");
TInt indicatorCapsStatus = aMobilePhone.GetIndicatorCaps(actionCaps,
indCaps);
LOG1(ESOCKET, EInfo, "MOBINFO Checking IndicatorCaps status=%D",
indicatorCapsStatus);
if (indicatorCapsStatus == KErrNone)
{
TRequestStatus status;
if (indCaps & RMobilePhone::KCapsGetIndicator)
{
LOG(ESOCKET, EInfo, "MOBINFO retrieving Network Availability");
TUint32 indicator;
aMobilePhone.GetIndicator(status, indicator);
User::WaitForRequest(status);
User::LeaveIfError(status.Int());
LOG(ESOCKET, EInfo,
"MOBINFO returning property NetworkAvailability");
if (indicator & RMobilePhone::KIndNetworkAvailable)
{
telephonyProperty = HBufC::NewL(KMaxPropertySize);
telephonyProperty->Des().Append(KNetworkAvailable);
}
else
{
telephonyProperty = HBufC::NewL(KMaxPropertySize);
telephonyProperty->Des().Append(KNetworkUnavailable);
}
}
}
}
else if (aProperty == OPERATOR_NAME)
{
// Get Service Provider Name
LOG(ESOCKET, EInfo, "MOBINFO Getting Operator Name");
TUint32 networkCaps;
User::LeaveIfError(aMobilePhone.GetNetworkCaps(networkCaps));
// If the device is in 'offline' mode, the current network
// cannot be queried. Try to check the mode from cenrep.
TBool networkConnAllowed (ETrue);
CRepository* repository = CRepository::NewL(KCRUidCoreApplicationUIs);
// Ignore the return value
(void)repository->Get(KCoreAppUIsNetworkConnectionAllowed, networkConnAllowed);
delete repository;
if ((networkCaps & RMobilePhone::KCapsGetCurrentNetwork) && networkConnAllowed)
{
RMobilePhone::TMobilePhoneNetworkInfoV2 currInfo;
RMobilePhone::TMobilePhoneNetworkInfoV2Pckg currInfoPckg(currInfo);
RMobilePhone::TMobilePhoneLocationAreaV1 area;
TRequestStatus status;
aMobilePhone.GetCurrentNetwork(status, currInfoPckg, area);
User::WaitForRequest(status);
User::LeaveIfError(status.Int());
if (currInfo.iLongName.Length() > 0)
{
telephonyProperty = HBufC::NewL(currInfo.iLongName.Length() + 1);
telephonyProperty->Des().Append(currInfo.iLongName);
}
else if (currInfo.iDisplayTag.Length() > 0)
{
currInfo.iLongName = currInfo.iDisplayTag.Left( currInfo.iLongName.MaxLength() );
telephonyProperty = HBufC::NewL(currInfo.iLongName.Length() + 1);
telephonyProperty->Des().Append(currInfo.iLongName);
}
}
}
else if (aProperty == SERVICE_PROVIDER_NAME)
{
// Get Service Provider Name
LOG(ESOCKET, EInfo, "MOBINFO Getting Service Provider Name");
RMobilePhone::TMobilePhoneServiceProviderNameV2 serviceProviderName;
RMobilePhone::TMobilePhoneServiceProviderNameV2Pckg
serviceProviderNamePckg( serviceProviderName );
TRequestStatus status;
aMobilePhone.GetServiceProviderName(status, serviceProviderNamePckg);
User::WaitForRequest(status);
// Operator name, service provider
if (serviceProviderName.iSPName.Length() > 0)
{
telephonyProperty = HBufC::NewL(serviceProviderName.iSPName.Length() + 1);
telephonyProperty->Des().Append(serviceProviderName.iSPName);
}
else
{
// API call failed or empty service provider name
telephonyProperty = HBufC::NewL(KNameNotAvailable().Length() + 1);
telephonyProperty->Des().Append(KNameNotAvailable);
}
}
LOG(ESOCKET, EInfo, "MOBINFO - GetNetworkPropertyL()");
return telephonyProperty;
}
// ---------------------------------------------------------------------------
// Retrieves the date and time format related properties.
// @param aProperty name of the actual property
// @return error code
// -----------------------------------------------------------------------------
HBufC* GetDateTimePropertyL(const TInt aProperty)
{
JELOG2(ESOCKET);
HBufC* property = HBufC::NewMax(KMaxPropertySize);
TLocale locale;
TDateFormat dformat;
TChar dseparator;
TTimeFormat tformat;
TChar separator;
switch (aProperty)
{
case DATEFORMAT:
dformat = locale.DateFormat();
dseparator = locale.DateSeparator(1);
switch (dformat)
{
case EDateAmerican:
property->Des().Copy(_L("MM"));
property->Des().Append(dseparator);
property->Des().Append(_L("dd"));
property->Des().Append(dseparator);
property->Des().Append(_L("yyyy"));
break;
case EDateEuropean:
property->Des().Copy(_L("dd"));
property->Des().Append(dseparator);
property->Des().Append(_L("MM"));
property->Des().Append(dseparator);
property->Des().Append(_L("yyyy"));
break;
case EDateJapanese:
property->Des().Copy(_L("yyyy"));
property->Des().Append(dseparator);
property->Des().Append(_L("MM"));
property->Des().Append(dseparator);
property->Des().Append(_L("dd"));
break;
}
break;
case TIMEFORMAT:
tformat = locale.TimeFormat();
separator = locale.TimeSeparator(1);
switch (tformat)
{
case ETime12:
property->Des().Copy(_L("hh"));
property->Des().Append(separator);
property->Des().Append(_L("mm a"));
break;
case ETime24:
property->Des().Copy(_L("HH"));
property->Des().Append(separator);
property->Des().Append(_L("mm"));
break;
}
}
return property;
}
// ---------------------------------------------------------------------------
// Retrieves the network related properties.
// @param aMobilePhone initialized RMobilePhone instance.
// @param aTelServer initialized RTelServer instance.
// @return property value
// ---------------------------------------------------------------------------
HBufC* GetMSISDNPropertyL(RMobilePhone& aMobilePhone, RTelServer& aTelServer)
{
JELOG2(ESOCKET);
LOG(ESOCKET, EInfo, "MOBINFO + GetMSISDNPropertyL()");
HBufC* property = NULL;
// get default TSY name
HBufC* tsyName = HBufC16::NewLC(KCommsDbSvrMaxFieldLength);
TPtr tsyPtr(tsyName->Des());
GetDefaultTSYL(tsyPtr); // used in GetDefaultPhone()
LOG(ESOCKET, EInfo, "MOBINFO Retrieving info about for own number store");
TBool supported;
User::LeaveIfError(aTelServer.IsSupportedByModule(tsyPtr,
KETelFuncMobileOwnNumberStore, supported));
LOG1(
ESOCKET,
EInfo,
"MOBINFO Checking own number store suppport by TSY, supported = %D: ",
(TInt) supported);
CleanupStack::PopAndDestroy(tsyName);
if (supported)
{
RMobileONStore ownNumberStore;
User::LeaveIfError(ownNumberStore.Open(aMobilePhone));
CleanupClosePushL(ownNumberStore);
RMobileONStore::TMobileONStoreInfoV1 ownStoreInfo;
RMobileONStore::TMobileONStoreInfoV1Pckg ownStoreInfoPckg(ownStoreInfo);
TRequestStatus status;
ownNumberStore.GetInfo(status, ownStoreInfoPckg);
User::WaitForRequest(status);
LOG1(ESOCKET, EInfo,
"MOBINFO Checking getting own number store info status = %D ",
status.Int());
User::LeaveIfError(status.Int());
TInt ownStoreInfoUsedEntries = ownStoreInfo.iUsedEntries;
LOG1(ESOCKET, EInfo,
"MOBINFO Entries stored in own number store: %D ",
ownStoreInfoUsedEntries);
if (ownStoreInfoUsedEntries >= 1)
{
// calculate length for property
TInt size = ownStoreInfoUsedEntries
* RMobileONStore::KOwnNumberTextSize;
// take into account separators if more than one entry stored
size = size + ((ownStoreInfoUsedEntries - 1)
* KMSISDNSeparator().Length());
property = HBufC::NewL(size);
for (TInt index = 1; index <= ownStoreInfoUsedEntries; index++)
{
LOG(ESOCKET, EInfo, "MOBINFO Retrieving property MSISDN ");
RMobileONStore::TMobileONEntryV1 ownNumberEntry;
ownNumberEntry.iIndex = index; // = index
RMobileONStore::TMobileONEntryV1Pckg ownNumberEntryPckg(
ownNumberEntry);
status = KRequestPending;
ownNumberStore.Read(status, ownNumberEntryPckg);
User::WaitForRequest(status);
LOG1(ESOCKET, EInfo,
"MOBINFO Checking reading entry status = ",
status.Int());
User::LeaveIfError(status.Int());
LOG(ESOCKET, EInfo, "MOBINFO Returning property MSISDN");
property->Des().Append(ownNumberEntry.iNumber.iTelNumber);
if (index < ownStoreInfoUsedEntries)
{
property->Des().Append(KMSISDNSeparator);
}
}
}
CleanupStack::PopAndDestroy(&ownNumberStore);
}
LOG(ESOCKET, EInfo, "MOBINFO - GetMSISDNPropertyL()");
return property;
}
// ---------------------------------------------------------------------------
// The funtion used for "Telephony related" properties which are requires an
// initialized RTel server and RMobilePhone.
// @param aProperty name of the actual property
// @return property value
// -----------------------------------------------------------------------------
HBufC* GetTelephonyPropertyL(const TInt aProperty)
{
JELOG2(ESOCKET);
LOG(ESOCKET, EInfo, "MOBINFO + GetTelephonyPropertyL");
// Construct a connection to the RTel server
RTelServer telServer;
User::LeaveIfError(telServer.Connect());
LOG(ESOCKET, EInfo,
"MOBINFO GetTelephonyPropertyL: connected to the RTel server");
CleanupClosePushL(telServer);
RMobilePhone mobilePhone;
CleanupClosePushL(mobilePhone);
GetDefaultPhoneL(mobilePhone, telServer);
LOG(ESOCKET, EInfo,
"MOBINFO GetTelephonyPropertyL: after get default phoneconnected to the RTel server");
HBufC* telephonyProperty = NULL;
switch (aProperty)
{
case IMSI:
case IMEI:
telephonyProperty = GetIdentityPropertyL(mobilePhone, aProperty);
break;
case MSISDN:
telephonyProperty = GetMSISDNPropertyL(mobilePhone, telServer);
break;
case BATTERY_LEVEL:
telephonyProperty = GetBatteryPropertyL(mobilePhone);
break;
case NETWORK_ID:
case NETWORK_SIGNAL:
case NETWORK_AVAILABILITY:
case COUNTRY_CODE:
case CELLID:
case NETWORKSTATUS:
case SERVICE_PROVIDER_NAME:
case OPERATOR_NAME:
telephonyProperty = GetNetworkPropertyL(mobilePhone, aProperty);
break;
}
CleanupStack::PopAndDestroy(&mobilePhone);
CleanupStack::PopAndDestroy(&telServer);
LOG(ESOCKET, EInfo, "MOBINFO - GetTelephonyPropertyL()");
return telephonyProperty;
}
// ---------------------------------------------------------------------------
// Get type network access of currently used active connection
// @return network access, ownership hand over
// ---------------------------------------------------------------------------
HBufC* GetNetworkAccessL(TUint32 aAppDefaultApn, const TUint32 aAppDefaultApType)
{
LOG(ESOCKET, EInfo, "MOBINFO + GetNetworkAccessL");
HBufC* bearerType = NULL;
TUint32 iapId = GetUsedIapL();
if (iapId != 0)
{
// active connection present, opened by MIDlet.
bearerType = GetBearerTypeL(iapId);
}
else
{
// if there is no active connection by the application, return the app default bearer type.
if (aAppDefaultApType == 3)
{
// app default is IAP
bearerType = GetAppDefIapBearerTypeL(aAppDefaultApn);
}
else
{
bearerType = GetIapBearerTypeL(aAppDefaultApn,aAppDefaultApType);
}
}
LOG(ESOCKET, EInfo, "MOBINFO - GetNetworkAccessL");
return bearerType;
}
//// ---------------------------------------------------------------------------
//// Check if device default is set (SNAP or IAP)
//// @return true if device default defined, else false
//// ---------------------------------------------------------------------------
bool isDeviceDefaultPresentL()
{
TCmDefConnType type;
RCmManager * mgr = new(ELeave) RCmManager();
mgr->OpenL();
TCmDefConnValue obj;
mgr->ReadDefConnL(obj);
type = obj.iType;
if ((type!=ECmDefConnConnectionMethod) && (type!=ECmDefConnDestination))
{
// device default is other than SNAP or IAP
return false;
}
else
{
return true;
}
}
//// ---------------------------------------------------------------------------
//// Get bearer type of Access point ID
//// @return bearer type Acess point ID
//// ---------------------------------------------------------------------------
HBufC* GetIapBearerTypeL(const TUint32 aAppDefaultApn, const TUint32 aAppDefaultApType)
{
LOG(ESOCKET, EInfo, "MOBINFO + GetIapBearerTypeL()");
RConnectionMonitor monitor;
TUint connectionCount(0);
TUint iapId(0);
TRequestStatus status(KErrNone);
HBufC* bearerType(NULL);
TUint connectionId(0);
TUint subConnectionCount(0);
TConnMonBearerInfo bearerInfo(EBearerInfoUnknown);
bool flag = false;
TUint connIdx = 1;
User::LeaveIfError(monitor.ConnectL());
CleanupClosePushL(monitor);
status = KRequestPending;
monitor.GetConnectionCount(connectionCount, status);
User::WaitForRequest(status);
User::LeaveIfError(status.Int());
LOG1(ESOCKET, EInfo, "MOBINFO: GetIapBearerTypeL: Count of active connections: %D", connectionCount);
// Go through all connections
for (connIdx = 1; connIdx <= connectionCount; ++connIdx)
{
connectionId = 0;
subConnectionCount = 0;
flag = false;
// Get connection ID
monitor.GetConnectionInfo(connIdx, connectionId, subConnectionCount);
User::LeaveIfError(connectionId);
// Get connection IAP ID
status = KRequestPending;
monitor.GetUintAttribute(connectionId, 0, KIAPId, iapId, status);
User::WaitForRequest(status);
User::LeaveIfError(status.Int());
LOG1(ESOCKET, EInfo, "MOBINFO: GetIapBearerTypeL Connection 's IAP ID found: %D", iapId);
if (aAppDefaultApType == 2)
{
LOG(ESOCKET, EInfo, "MOBINFO: Matching MIDlet defined SNAP to active IAP ID ");
// Midlet has a SNAP defined, so check if the active IAP is under this SNAP.
flag = ConnectionManager::isIapDefault(iapId, aAppDefaultApn,false);
if (!flag)
{
continue; // active access point doesn't belong to MIDlet SNAP, check the next active access point.
}
else
{
break;
}
}
else
{
// No SNAP defined for the MIDlet, check for system default SNAP/IAP.
if (isDeviceDefaultPresentL())
{
LOG(ESOCKET, EInfo, "MOBINFO: Matching device default to active IAP ID ");
flag = ConnectionManager::isIapDefault(iapId, 0, true);
if (!flag)
{
continue; // active access point doesn't belong to MIDlet SNAP, check the next active access point.
}
else
{
break;
}
}
else
{
LOG(ESOCKET, EInfo, "MOBINFO: Returning the bearer type of first active IAP ");
flag = true;
break; // no MIDlet SNAP, no device default, select this access point and return the bearer type
}
}
} // end of for loop
if (flag)
{
// we did not reach end of active connections, one of the conditions matched , find the bearer type
status = KRequestPending;
monitor.GetIntAttribute(connectionId,
0,
KBearerInfo,
(TInt&)bearerInfo,
status);
User::WaitForRequest(status);
User::LeaveIfError(status.Int());
// Translate bearer type to type of network access
bearerType = TranslateBearerInfoToNetworkAccessL(bearerInfo);
}
CleanupStack::PopAndDestroy(&monitor);
if (bearerType == NULL)
{
// No active connection (or) active IAP didn't match the conditions
bearerType = KNetworkAccessNa().AllocL();
}
return bearerType;
}
//// ---------------------------------------------------------------------------
//// Get currently used Access point ID
//// @return currently used Acess point ID
//// ---------------------------------------------------------------------------
TUint32 GetUsedIapL()
{
LOG(ESOCKET, EInfo, "MOBINFO + GetUsedIapL()");
RSocketServ socketServer;
RConnection connection;
TConnEnumArgBuf enumArgBuf;
TConnGetClientInfoArgBuf clientInfoBuf;
TUint connectionCount(0);
TConnectionInfoBuf connInfoBuf;
TUint32 iapId(0);
// Get MIDlet process ID
RProcess process;
RThread thread;
TProcessId currProcessId(process.Id());
TThreadId currThreadId(thread.Id());
//LOG1( ESOCKET, EInfo, "MOBINFO Current process ID: %D", currProcessId );
//LOG1( ESOCKET, EInfo, "MOBINFO Current thread ID: %D", currThreadId );
// Connect to socket server and use system global pool (-1)
// for message slots.
LOG(ESOCKET, EInfo, "MOBINFO Connecting to socket server");
User::LeaveIfError(socketServer.Connect(static_cast< TUint >(-1)));
CleanupClosePushL(socketServer);
LOG(ESOCKET, EInfo, "MOBINFO Connected to socket server");
// Open RConnection,
// this object is not attached to any connection
LOG(ESOCKET, EInfo, "MOBINFO Opening connection");
User::LeaveIfError(connection.Open(socketServer));
CleanupClosePushL(connection);
LOG(ESOCKET, EInfo, "MOBINFO Connection opened");
// Get count of current active connections.
LOG(ESOCKET, EInfo, "MOBINFO Getting count of current active connections");
User::LeaveIfError(connection.EnumerateConnections(connectionCount));
LOG1(ESOCKET, EInfo, "MOBINFO Count of active connections %D", connectionCount);
// Go through all active connections
for (TUint connIdx = 1; connIdx <= connectionCount && iapId == 0; connIdx++)
{
enumArgBuf().iIndex = connIdx;
// Get the number of clients
LOG1(ESOCKET, EInfo, "MOBINFO Getting number of clients for active connection %D.", connIdx);
User::LeaveIfError(connection.Control
(
KCOLConnection,
KCoEnumerateConnectionClients,
enumArgBuf
)
);
LOG1(ESOCKET, EInfo, "MOBINFO Number of clients: %D", enumArgBuf().iCount);
// Go through all clients
for (TUint clientIdx = 1;
clientIdx <= enumArgBuf().iCount && iapId == 0; clientIdx++)
{
clientInfoBuf().iIndex = clientIdx;
LOG1(ESOCKET, EInfo, "MOBINFO Retreiving client %D. info", clientIdx);
User::LeaveIfError(connection.Control
(
KCOLConnection,
KCoGetConnectionClientInfo,
clientInfoBuf
)
);
LOG(ESOCKET, EInfo, "MOBINFO Client info retreived: ");
TUid uid(clientInfoBuf().iClientInfo.iUid);
TProcessId processId(clientInfoBuf().iClientInfo.iProcessId);
TThreadId threadId(clientInfoBuf().iClientInfo.iThreadId);
LOG1(ESOCKET, EInfo, "MOBINFO Client UID: %D", uid.iUid);
//LOG1( ESOCKET, EInfo, "MOBINFO Client process ID: %D", processId );
//LOG1( ESOCKET, EInfo, "MOBINFO Client thread ID: %D", threadId );
// MIDlet's active connection found
if (uid.iUid == KJVMProcessUid && currProcessId == processId)
{
LOG(ESOCKET, EInfo, "MOBINFO Active connection of current MIDlet found");
TConnectionInfoBuf connInfoBuf;
LOG1(ESOCKET, EInfo, "MOBINFO Getting connection info %D", clientIdx);
User::LeaveIfError(
connection.GetConnectionInfo(connIdx, connInfoBuf)
);
LOG(ESOCKET, EInfo, "MOBINFO Connection info gotten");
iapId = connInfoBuf().iIapId;
LOG1(ESOCKET, EInfo, "MOBINFO currently used IAP ID found: %D", iapId);
}
}
}
LOG1(ESOCKET, EInfo, "MOBINFO currently used IAP ID: %D", iapId);
CleanupStack::PopAndDestroy(&connection);
CleanupStack::PopAndDestroy(&socketServer);
LOG(ESOCKET, EInfo, "MOBINFO - GetUsedIapL()");
return iapId;
}
// ---------------------------------------------------------------------------
// Get IAP's bearer type
// @param aIapId IAP ID
// @return bearer type, ownership handed over
// "LAN" Local area network
// 'pd.GSM" Packet data in GSM network
// "pd.EDGE" Packet data in EDGE network
// "pd.3G" Packet data in 3G network
// "csd" Circuit switched data, for example GSM CSD/HSCSD data call
// "bt_pan" Bluetooth PAN network
// "wlan" Wireless network, for example 802.11b, 802.11G or WiMaX
// "hspda" High speed downlink packet access for 3G networks
// "na" Not applicable, the implementation can’t determine the type
// ---------------------------------------------------------------------------
HBufC* GetBearerTypeL(TUint32 aIapId)
{
LOG(ESOCKET, EInfo, "MOBINFO + GetBearerTypeL()");
RConnectionMonitor monitor;
TUint connectionCount(0);
TUint iapId(0);
TRequestStatus status(KErrNone);
HBufC* bearerType(NULL);
TUint connectionId(0);
TUint subConnectionCount(0);
TConnMonBearerInfo bearerInfo(EBearerInfoUnknown);
LOG(ESOCKET, EInfo, "MOBINFO Connecting to Connection Monitor");
User::LeaveIfError(monitor.ConnectL());
CleanupClosePushL(monitor);
LOG(ESOCKET, EInfo, "MOBINFO Connected to Connection Monitor");
LOG(ESOCKET, EInfo, "MOBINFO Getting count of active connections");
status = KRequestPending;
monitor.GetConnectionCount(connectionCount, status);
User::WaitForRequest(status);
User::LeaveIfError(status.Int());
LOG1(ESOCKET, EInfo, "MOBINFO Count of active connections: %D", connectionCount);
// Go through all connections
for (TUint connIdx = 1; connIdx <= connectionCount && iapId == 0;
++connIdx)
{
connectionId = 0;
subConnectionCount = 0;
// Get connection ID
LOG1(ESOCKET, EInfo, "MOBINFO Getting connection info %D", connIdx);
monitor.GetConnectionInfo(connIdx, connectionId, subConnectionCount);
User::LeaveIfError(connectionId);
LOG(ESOCKET, EInfo, "MOBINFO Connection info gotten");
// Get connection IAP ID
LOG1(ESOCKET, EInfo, "MOBINFO Getting connection %D IAP ID", connIdx);
status = KRequestPending;
monitor.GetUintAttribute(connectionId, 0, KIAPId, iapId, status);
User::WaitForRequest(status);
User::LeaveIfError(status.Int());
LOG1(ESOCKET, EInfo, "MOBINFO Connection 's IAP ID found: %D", iapId);
if (iapId == aIapId)
{
// MIDlet's IAP found
LOG(ESOCKET, EInfo, "MOBINFO Midlet's IAP found");
// Get bearer type
LOG(ESOCKET, EInfo, "MOBINFO Getting bearer type");
status = KRequestPending;
monitor.GetIntAttribute(connectionId,
0,
KBearerInfo,
(TInt&)bearerInfo,
status);
User::WaitForRequest(status);
User::LeaveIfError(status.Int());
LOG1(ESOCKET, EInfo, "MOBINFO Bearer type found: %D", bearerInfo);
}
}
// Translate bearer type to type of network access
bearerType = TranslateBearerInfoToNetworkAccessL(bearerInfo);
CleanupStack::PopAndDestroy(&monitor);
LOG(ESOCKET, EInfo, "MOBINFO - GetBearerTypeL()");
return bearerType;
}
// ---------------------------------------------------------------------------
// Translate bearer info to type of network access
// @param aBearerInfo bearer info
// @return type of network access, ownership hand over
HBufC* TranslateBearerInfoToNetworkAccessL(TConnMonBearerInfo aBearerInfo)
{
LOG(ESOCKET, EInfo, "MOBINFO + TranslateBearerInfoToNetworkAccessL()");
HBufC* bearerType(NULL);
switch (aBearerInfo)
{
case EBearerInfoLAN:
bearerType = KNetworkAccessPdLAN().AllocL();
break;
case EBearerInfoGPRS:
bearerType = KNetworkAccessPdGSM().AllocL();
break;
case EBearerInfoEdgeGPRS:
bearerType = KNetworkAccessPdEDGE().AllocL();
break;
case EBearerInfoWCDMA:
bearerType = KNetworkAccessPd3G().AllocL();
break;
case EBearerInfoCSD:
case EBearerInfoHSCSD:
case EBearerInfoWcdmaCSD:
bearerType = KNetworkAccessCSD().AllocL();
break;
case EBearerInfoBluetooth:
bearerType = KNetworkAccessBtPan().AllocL();
break;
case EBearerInfoWLAN:
bearerType = KNetworkAccessWLAN().AllocL();
break;
case EBearerInfoHSDPA:
case EBearerInfoHSUPA:
case EBearerInfoHSxPA:
bearerType = KNetworkAccessHSPDA().AllocL();
break;
case EBearerInfoUnknown:
case EBearerInfoCDMA2000:
case EBearerInfoVirtual:
case EBearerInfoVirtualVPN:
default:
bearerType = KNetworkAccessNa().AllocL();
break;
}
LOG(ESOCKET, EInfo, "MOBINFO - TranslateBearerInfoToNetworkAccessL()");
return bearerType;
}
// --------------------------------------------------------------------
// Get network access type of default access point set in MIDlet settings
// @param aAppDefaultApn MIDlet default IAP
// @return network access type, ownership hand over
HBufC* GetAppDefIapBearerTypeL(const TUint32 aAppDefaultApn)
{
LOG1(ESOCKET, EInfo, "MOBINFO + GetAppDefIapBearerTypeL aId = %d ", aAppDefaultApn);
HBufC* bearerType(NULL);
if (aAppDefaultApn == 0 || aAppDefaultApn == (TUint32)-1)
{
bearerType = KNetworkAccessNa().AllocL();
}
else
{
RCmManager localCmManager;
localCmManager.OpenL();
TUint32 iap = aAppDefaultApn;
TUint32 tmpval = localCmManager.GetConnectionMethodInfoIntL(iap,ECmBearerType);
ELOG1(ESOCKET, "GetConnectionMethodInfoIntL: %d", tmpval);
switch (tmpval)
{
case KUidHSCSDBearerType:
bearerType = KNetworkAccessCSD().AllocL();
break;
case KUidPacketDataBearerType:
bearerType = KNetworkAccessPdGSM().AllocL();
break;
case KUidWlanBearerType :
bearerType = KNetworkAccessWLAN().AllocL();
break;
/* Bearer type LAN,LANModem currently not supported by cmmanager */
default :
bearerType = KNetworkAccessNa().AllocL();
break;
}
}
LOG(ESOCKET, EInfo, "MOBINFO - GetAppDefIapBearerTypeL");
return bearerType;
}