19
|
1 |
/*
|
|
2 |
* Copyright (c) 2002 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 the License "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: CLandmarkManageHandlers class implementation
|
|
15 |
*
|
|
16 |
*/
|
|
17 |
|
|
18 |
|
|
19 |
#include <epos_cposlandmarkdatabase.h>
|
|
20 |
#include <epos_cposlmcategorymanager.h>
|
|
21 |
#include <epos_cposlandmarksearch.h>
|
|
22 |
#include <epos_TposLmDatabaseSettings.h>
|
|
23 |
#include "clandmarkmanagehandlers.h"
|
|
24 |
|
|
25 |
//class CLandmarkManageHandlers
|
|
26 |
// ============================ MEMBER FUNCTIONS ===============================
|
|
27 |
|
|
28 |
// -----------------------------------------------------------------------------
|
|
29 |
// CLandmarkManageHandlers::NewL()
|
|
30 |
// Two-phased constructor.
|
|
31 |
// -----------------------------------------------------------------------------
|
|
32 |
//
|
|
33 |
CLandmarkManageHandlers* CLandmarkManageHandlers::NewL( )
|
|
34 |
{
|
|
35 |
CLandmarkManageHandlers* self = new (ELeave) CLandmarkManageHandlers();
|
|
36 |
return self;
|
|
37 |
}
|
|
38 |
|
|
39 |
// -----------------------------------------------------------------------------
|
|
40 |
// CLandmarkManageHandlers::CLandmarkManageHandlers()
|
|
41 |
// C++ default constructor can NOT contain any code, that might leave.
|
|
42 |
// -----------------------------------------------------------------------------
|
|
43 |
//
|
|
44 |
CLandmarkManageHandlers::CLandmarkManageHandlers( )
|
|
45 |
{
|
|
46 |
}
|
|
47 |
|
|
48 |
// -----------------------------------------------------------------------------
|
|
49 |
// CLandmarkManageHandlers::~CLandmarkManageHandlers()
|
|
50 |
// Destructor.
|
|
51 |
// -----------------------------------------------------------------------------
|
|
52 |
//
|
|
53 |
CLandmarkManageHandlers::~CLandmarkManageHandlers( )
|
|
54 |
{
|
|
55 |
iHandlers.ResetAndDestroy ( );
|
|
56 |
iHandlers.Close();
|
|
57 |
}
|
|
58 |
|
|
59 |
// -----------------------------------------------------------------------------
|
|
60 |
// CLandmarkManageHandlers::CloseHandler( CLandmarkHandler* aHandler )
|
|
61 |
// Closes the passed CLandmarkHandler handle and removes it from the array.
|
|
62 |
// -----------------------------------------------------------------------------
|
|
63 |
//
|
|
64 |
void CLandmarkManageHandlers::CloseHandler( CLandmarkHandler* aHandler )
|
|
65 |
{
|
|
66 |
TInt index = iHandlers.Find (aHandler );
|
|
67 |
if ( index != KErrNotFound )
|
|
68 |
{
|
|
69 |
delete iHandlers[index];
|
|
70 |
iHandlers[index] = NULL;
|
|
71 |
iHandlers.Remove (index );
|
|
72 |
}
|
|
73 |
}
|
|
74 |
// -----------------------------------------------------------------------------
|
|
75 |
// CLandmarkManageHandlers::CreateHandlerL(TDesC & aDatabaseUri)
|
|
76 |
// Creates and Returns the handle of CLandmarkHandler instance.
|
|
77 |
// -----------------------------------------------------------------------------
|
|
78 |
//
|
|
79 |
CLandmarkHandler* CLandmarkManageHandlers::CreateHandlerL(
|
|
80 |
const TDesC& aDatabaseUri )
|
|
81 |
{
|
|
82 |
//create a database handle and append to the array.
|
|
83 |
CLandmarkHandler* handler = CLandmarkHandler::CreateL (aDatabaseUri );
|
|
84 |
CleanupStack::PushL (handler );
|
|
85 |
iHandlers.AppendL (handler );
|
|
86 |
CleanupStack::Pop (handler );
|
|
87 |
//if there is no default handler then set default as device default
|
|
88 |
if( !iDefaultHandler && aDatabaseUri == KNullDesC )
|
|
89 |
{
|
|
90 |
iDefaultHandler = handler;
|
|
91 |
}
|
|
92 |
return handler;
|
|
93 |
}
|
|
94 |
|
|
95 |
// -----------------------------------------------------------------------------
|
|
96 |
// CLandmarkManageHandlers::GetHandlerL(TDesC & aDatabaseUri)
|
|
97 |
// Returns the handle of CLandmarkHandler instance.
|
|
98 |
// -----------------------------------------------------------------------------
|
|
99 |
//
|
|
100 |
CLandmarkHandler* CLandmarkManageHandlers::GetHandlerL(const TDesC& aDatabaseUri )
|
|
101 |
{
|
|
102 |
_LIT(KDriveSeparatorSymbol, ":");
|
|
103 |
_LIT(KDefaultDriveLocal, "c");
|
|
104 |
_LIT(KProtocolSeparatorLocal, "://");
|
|
105 |
_LIT(KLocalProtocolString, "file");
|
|
106 |
|
|
107 |
CLandmarkHandler* handler= NULL;
|
|
108 |
//if aDatabaseUri is KNullDesC then return the default handler
|
|
109 |
if ( aDatabaseUri == KNullDesC )
|
|
110 |
{
|
|
111 |
if ( iDefaultHandler )
|
|
112 |
{
|
|
113 |
iDefaultHandler->InitL ( );
|
|
114 |
}
|
|
115 |
handler = iDefaultHandler;
|
|
116 |
}
|
|
117 |
//else compare the passed URI with the stored handle's URI
|
|
118 |
else
|
|
119 |
{
|
|
120 |
//Simple parsing. Have to implement better parsing
|
|
121 |
TBuf<KPosLmDatabaseName> dbName;
|
|
122 |
TInt offset = aDatabaseUri.Find (KProtocolSeparatorLocal );
|
|
123 |
if ( KErrNotFound == offset )
|
|
124 |
{
|
|
125 |
dbName.Copy (KLocalProtocolString );
|
|
126 |
dbName.Append (KProtocolSeparatorLocal );
|
|
127 |
}
|
|
128 |
if ( aDatabaseUri.Find (KDriveSeparatorSymbol )<= offset )
|
|
129 |
{
|
|
130 |
dbName.Append (KDefaultDriveLocal );
|
|
131 |
dbName.Append (KDriveSeparatorSymbol );
|
|
132 |
}
|
|
133 |
//Check for Length < KPosLmDatabaseName
|
|
134 |
if ( (aDatabaseUri.Length() + dbName.Length()) > KPosLmDatabaseName )
|
|
135 |
{
|
|
136 |
User::Leave ( KErrBadName );
|
|
137 |
}
|
|
138 |
//create the complete db uri
|
|
139 |
dbName.Append (aDatabaseUri );
|
|
140 |
//normalize to lower
|
|
141 |
dbName.LowerCase ( );
|
|
142 |
TInt count = iHandlers.Count ( );
|
|
143 |
TPtrC dbUri;
|
|
144 |
while ( count )
|
|
145 |
{
|
|
146 |
//Retrieve the handles from end
|
|
147 |
handler = iHandlers[--count];
|
|
148 |
handler->GetDatabaseUri (dbUri );
|
|
149 |
if ( dbUri == dbName )
|
|
150 |
{
|
|
151 |
handler->InitL ( );
|
|
152 |
break;
|
|
153 |
}
|
|
154 |
//if no handle found then NULL
|
|
155 |
handler = NULL;
|
|
156 |
}
|
|
157 |
}
|
|
158 |
return handler;
|
|
159 |
}
|
|
160 |
|
|
161 |
// -----------------------------------------------------------------------------
|
|
162 |
// CLandmarkManageHandlers::SetDefaultHandler(CLandmarkHandler* aHandler)
|
|
163 |
// Sets the default handler.
|
|
164 |
// -----------------------------------------------------------------------------
|
|
165 |
//
|
|
166 |
void CLandmarkManageHandlers::SetDefaultHandler( CLandmarkHandler* aHandler )
|
|
167 |
{
|
|
168 |
iDefaultHandler = aHandler;
|
|
169 |
}
|
|
170 |
|
|
171 |
//Class CLandmarkHandler
|
|
172 |
// ============================ MEMBER FUNCTIONS ===============================
|
|
173 |
|
|
174 |
// -----------------------------------------------------------------------------
|
|
175 |
// CLandmarkHandler::CreateL( TDesC & aDatabaseUri )
|
|
176 |
// Two-phased constructor.
|
|
177 |
// -----------------------------------------------------------------------------
|
|
178 |
//
|
|
179 |
CLandmarkHandler* CLandmarkHandler::CreateL( const TDesC& aDatabaseUri )
|
|
180 |
{
|
|
181 |
CLandmarkHandler* self = new (ELeave) CLandmarkHandler();
|
|
182 |
CleanupStack::PushL ( self );
|
|
183 |
self->ConstructL (aDatabaseUri );
|
|
184 |
CleanupStack::Pop ( self );
|
|
185 |
return self;
|
|
186 |
}
|
|
187 |
|
|
188 |
// -----------------------------------------------------------------------------
|
|
189 |
// CLandmarkHandler::ConstructL( TDesC & aDatabaseUri )
|
|
190 |
// Symbian 2nd phase constructor can leave.
|
|
191 |
// -----------------------------------------------------------------------------
|
|
192 |
//
|
|
193 |
void CLandmarkHandler::ConstructL( const TDesC& aDatabaseUri )
|
|
194 |
{
|
|
195 |
//Open default database or the database requested depending on paramater aDatabaseUri
|
|
196 |
if ( aDatabaseUri != KNullDesC )
|
|
197 |
{
|
|
198 |
iLandmarkDatabaseHandle = CPosLandmarkDatabase::OpenL (aDatabaseUri );
|
|
199 |
}
|
|
200 |
else
|
|
201 |
{
|
|
202 |
iLandmarkDatabaseHandle = CPosLandmarkDatabase::OpenL ( );
|
|
203 |
}
|
|
204 |
iDatabaseUri = iLandmarkDatabaseHandle->DatabaseUriLC ( );
|
|
205 |
CleanupStack::Pop (iDatabaseUri );
|
|
206 |
//Normalize to lower
|
|
207 |
iDatabaseUri->Des().LowerCase ( );
|
|
208 |
//initialize the database for further opertaions on the database.
|
|
209 |
ExecuteAndDeleteLD (iLandmarkDatabaseHandle->InitializeL ( ) );
|
|
210 |
//Create other handles with respect to the open database
|
|
211 |
iLmCategoryManagerHandle = CPosLmCategoryManager::NewL (*iLandmarkDatabaseHandle );
|
|
212 |
iLandmarkSearchHandle = CPosLandmarkSearch::NewL (*iLandmarkDatabaseHandle );
|
|
213 |
}
|
|
214 |
|
|
215 |
// -----------------------------------------------------------------------------
|
|
216 |
// CLandmarkHandler::CLandmarkHandler()
|
|
217 |
// C++ default constructor can NOT contain any code, that might leave.
|
|
218 |
// -----------------------------------------------------------------------------
|
|
219 |
//
|
|
220 |
CLandmarkHandler::CLandmarkHandler( )
|
|
221 |
{
|
|
222 |
}
|
|
223 |
|
|
224 |
// -----------------------------------------------------------------------------
|
|
225 |
// CLandmarkHandler::~CLandmarkHandler()
|
|
226 |
// Destructor.
|
|
227 |
// -----------------------------------------------------------------------------
|
|
228 |
//
|
|
229 |
CLandmarkHandler::~CLandmarkHandler( )
|
|
230 |
{
|
|
231 |
delete iLandmarkSearchHandle;
|
|
232 |
delete iLmCategoryManagerHandle;
|
|
233 |
delete iLandmarkDatabaseHandle;
|
|
234 |
delete iDatabaseUri;
|
|
235 |
}
|
|
236 |
|
|
237 |
// -----------------------------------------------------------------------------
|
|
238 |
// CLandmarkHandler::InitL()
|
|
239 |
// Initialize the databse if required.
|
|
240 |
// -----------------------------------------------------------------------------
|
|
241 |
//
|
|
242 |
void CLandmarkHandler::InitL( )
|
|
243 |
{
|
|
244 |
if (iLandmarkDatabaseHandle->IsInitializingNeeded ( ) )
|
|
245 |
{
|
|
246 |
//Initialize the database for further opertaions on the database.
|
|
247 |
ExecuteAndDeleteLD (iLandmarkDatabaseHandle->InitializeL ( ) );
|
|
248 |
}
|
|
249 |
}
|
|
250 |
|
|
251 |
// End of File
|