| changeset 31 | 56f325a607ea |
| parent 0 | a41df078684a |
| child 39 | 5d2844f35677 |
| 15:4122176ea935 | 31:56f325a607ea |
|---|---|
42 TSettingType aType, UValueWord& aValue) |
42 TSettingType aType, UValueWord& aValue) |
43 { |
43 { |
44 HCR_FUNC("GetUValueWordSetting"); |
44 HCR_FUNC("GetUValueWordSetting"); |
45 |
45 |
46 if (HCRNotReady) |
46 if (HCRNotReady) |
47 HCR_LOG_RETURN(KErrNotReady); |
47 HCR_TRACE_RETURN(KErrNotReady); |
48 |
48 |
49 TSettingRef sref(0,0); |
49 TSettingRef sref(0,0); |
50 TInt err = 0; |
50 TInt err = 0; |
51 err = HCRSingleton->FindSetting(aId, aType, sref); |
51 err = HCRSingleton->FindSetting(aId, aType, sref); |
52 if (err != KErrNone) |
52 if (err != KErrNone) |
53 HCR_LOG_RETURN(err); |
53 HCR_TRACE_RETURN(err); |
54 |
54 |
55 err = sref.iRep->GetValue(sref, aValue); |
55 err = sref.iRep->GetValue(sref, aValue); |
56 if (err != KErrNone) |
56 if (err != KErrNone) |
57 HCR_LOG_RETURN(err); |
57 HCR_TRACE_RETURN(err); |
58 |
58 |
59 return KErrNone; |
59 return KErrNone; |
60 } |
60 } |
61 |
61 |
62 LOCAL_C TInt GetUValueLargeSetting64 (const TSettingId& aId, |
62 LOCAL_C TInt GetUValueLargeSetting64 (const TSettingId& aId, |
63 TSettingType aType, UValueLarge& aValue) |
63 TSettingType aType, UValueLarge& aValue) |
64 { |
64 { |
65 HCR_FUNC("GetUValueLargeSetting64"); |
65 HCR_FUNC("GetUValueLargeSetting64"); |
66 |
66 |
67 if (HCRNotReady) |
67 if (HCRNotReady) |
68 HCR_LOG_RETURN(KErrNotReady); |
68 HCR_TRACE_RETURN(KErrNotReady); |
69 |
69 |
70 __NK_ASSERT_DEBUG(aType == ETypeInt64 || aType == ETypeUInt64); |
|
71 |
|
70 TSettingRef sref(0,0); |
72 TSettingRef sref(0,0); |
71 TInt err = 0; |
73 TInt err = 0; |
72 err = HCRSingleton->FindSetting(aId, aType, sref); |
74 err = HCRSingleton->FindSetting(aId, aType, sref); |
73 if (err != KErrNone) |
75 if (err != KErrNone) |
74 HCR_LOG_RETURN(err); |
76 HCR_TRACE_RETURN(err); |
75 |
77 |
76 err = sref.iRep->GetLargeValue(sref, aValue); |
78 err = sref.iRep->GetLargeValue(sref, aValue); |
77 if (err != KErrNone) |
79 if (err != KErrNone) |
78 HCR_LOG_RETURN(err); |
80 HCR_TRACE_RETURN(err); |
79 |
81 |
80 return KErrNone; |
82 return KErrNone; |
81 } |
83 } |
82 |
84 |
83 |
85 |
85 TSettingType aType, TDes8& aValue) |
87 TSettingType aType, TDes8& aValue) |
86 { |
88 { |
87 HCR_FUNC("GetUValueLargeSettingTDes8"); |
89 HCR_FUNC("GetUValueLargeSettingTDes8"); |
88 |
90 |
89 if (HCRNotReady) |
91 if (HCRNotReady) |
90 HCR_LOG_RETURN(KErrNotReady); |
92 HCR_TRACE_RETURN(KErrNotReady); |
91 |
93 |
94 __NK_ASSERT_DEBUG(aType == ETypeBinData || aType == ETypeText8); |
|
95 |
|
92 TSettingRef sref(0,0); |
96 TSettingRef sref(0,0); |
93 TInt err = 0; |
97 TInt err = 0; |
94 err = HCRSingleton->FindSetting(aId, aType, sref); |
98 err = HCRSingleton->FindSetting(aId, aType, sref); |
95 if (err != KErrNone) |
99 if (err != KErrNone) |
96 HCR_LOG_RETURN(err); |
100 HCR_TRACE_RETURN(err); |
97 |
101 |
98 UValueLarge value; |
102 UValueLarge value; |
99 err = sref.iRep->GetLargeValue(sref, value); |
103 err = sref.iRep->GetLargeValue(sref, value); |
100 if (err != KErrNone) |
104 if (err != KErrNone) |
101 HCR_LOG_RETURN(err); |
105 HCR_TRACE_RETURN(err); |
102 |
106 |
103 TInt len = sref.iRep->GetLength(sref); |
107 TInt len = sref.iRep->GetLength(sref); |
104 if (len > aValue.MaxSize()) |
108 if (len > aValue.MaxSize()) |
105 HCR_LOG_RETURN(KErrTooBig); |
109 HCR_TRACE_RETURN(KErrTooBig); |
106 |
110 |
107 if (aType == ETypeBinData) |
111 if (aType == ETypeBinData) |
108 aValue.Copy(value.iData, len); |
112 aValue.Copy(value.iData, len); |
109 else |
113 else |
110 aValue.Copy(value.iString8, len); |
114 aValue.Copy(value.iString8, len); |
116 TUint16 aMaxLen, TUint8* aValue, TUint16& aLen) |
120 TUint16 aMaxLen, TUint8* aValue, TUint16& aLen) |
117 { |
121 { |
118 HCR_FUNC("GetUValueLargeSettingTUint8"); |
122 HCR_FUNC("GetUValueLargeSettingTUint8"); |
119 |
123 |
120 if (HCRNotReady) |
124 if (HCRNotReady) |
121 HCR_LOG_RETURN(KErrNotReady); |
125 HCR_TRACE_RETURN(KErrNotReady); |
122 |
126 |
127 __NK_ASSERT_DEBUG(aType == ETypeBinData || aType == ETypeText8); |
|
128 |
|
123 TSettingRef sref(0,0); |
129 TSettingRef sref(0,0); |
124 TInt err = 0; |
130 TInt err = 0; |
125 err = HCRSingleton->FindSetting(aId, aType, sref); |
131 err = HCRSingleton->FindSetting(aId, aType, sref); |
126 if (err != KErrNone) |
132 if (err != KErrNone) |
127 HCR_LOG_RETURN(err); |
133 HCR_TRACE_RETURN(err); |
128 |
134 |
129 UValueLarge value; |
135 UValueLarge value; |
130 err = sref.iRep->GetLargeValue(sref, value); |
136 err = sref.iRep->GetLargeValue(sref, value); |
131 if (err != KErrNone) |
137 if (err != KErrNone) |
132 HCR_LOG_RETURN(err); |
138 HCR_TRACE_RETURN(err); |
133 |
139 |
134 aLen = sref.iRep->GetLength(sref); |
140 aLen = sref.iRep->GetLength(sref); |
135 if (aLen > aMaxLen) |
141 if (aLen > aMaxLen) |
136 HCR_LOG_RETURN(KErrTooBig); |
142 HCR_TRACE_RETURN(KErrTooBig); |
137 |
143 |
138 if (aType == ETypeBinData) |
144 if (aType == ETypeBinData) |
139 memcpy (aValue, value.iData, aLen); |
145 memcpy (aValue, value.iData, aLen); |
140 else |
146 else |
141 memcpy (aValue, value.iString8, aLen); |
147 memcpy (aValue, value.iString8, aLen); |
147 TUint16 aMaxLen, TUint32* aValue, TUint16& aLen) |
153 TUint16 aMaxLen, TUint32* aValue, TUint16& aLen) |
148 { |
154 { |
149 HCR_FUNC("GetUValueLargeSettingArray"); |
155 HCR_FUNC("GetUValueLargeSettingArray"); |
150 |
156 |
151 if (HCRNotReady) |
157 if (HCRNotReady) |
152 HCR_LOG_RETURN(KErrNotReady); |
158 HCR_TRACE_RETURN(KErrNotReady); |
153 |
159 |
160 __NK_ASSERT_DEBUG(aType == ETypeArrayInt32 || aType == ETypeArrayUInt32); |
|
161 |
|
154 TSettingRef sref(0,0); |
162 TSettingRef sref(0,0); |
155 TInt err = 0; |
163 TInt err = 0; |
156 err = HCRSingleton->FindSetting(aId, aType, sref); |
164 err = HCRSingleton->FindSetting(aId, aType, sref); |
157 if (err != KErrNone) |
165 if (err != KErrNone) |
158 HCR_LOG_RETURN(err); |
166 HCR_TRACE_RETURN(err); |
159 |
167 |
160 UValueLarge value; |
168 UValueLarge value; |
161 err = sref.iRep->GetLargeValue(sref, value); |
169 err = sref.iRep->GetLargeValue(sref, value); |
162 if (err != KErrNone) |
170 __NK_ASSERT_DEBUG(err == KErrNone); |
163 HCR_LOG_RETURN(err); |
|
164 |
171 |
165 aLen = sref.iRep->GetLength(sref); |
172 aLen = sref.iRep->GetLength(sref); |
166 if (aLen > aMaxLen) |
173 if (aLen > aMaxLen) |
167 HCR_LOG_RETURN(KErrTooBig); |
174 HCR_TRACE_RETURN(KErrTooBig); |
168 |
175 |
169 if (aType == ETypeArrayInt32) |
176 if (aType == ETypeArrayInt32) |
170 memcpy (aValue, value.iArrayInt32, aLen); |
177 memcpy (aValue, value.iArrayInt32, aLen); |
171 else if (aType == ETypeArrayUInt32) |
178 else |
172 memcpy (aValue, value.iArrayUInt32, aLen); |
179 memcpy (aValue, value.iArrayUInt32, aLen); |
173 else |
|
174 HCR_LOG_RETURN(KErrGeneral); |
|
175 |
180 |
176 return KErrNone; |
181 return KErrNone; |
177 } |
182 } |
178 |
183 |
179 } |
184 } |
190 HCR_FUNC("HCR::GetInt8"); |
195 HCR_FUNC("HCR::GetInt8"); |
191 |
196 |
192 UValueWord value; |
197 UValueWord value; |
193 TInt err = GetUValueWordSetting(aId, ETypeInt8, value); |
198 TInt err = GetUValueWordSetting(aId, ETypeInt8, value); |
194 if (err != KErrNone) |
199 if (err != KErrNone) |
195 HCR_LOG_RETURN(err); |
200 HCR_TRACE_RETURN(err); |
196 |
201 |
197 aValue = value.iInt8; |
202 aValue = value.iInt8; |
198 return KErrNone; |
203 return KErrNone; |
199 #else |
204 #else |
200 return KErrNotSupported; |
205 HCR_TRACE_RETURN(KErrGeneral); |
201 #endif // MAKE_DEF_FILE |
206 #endif // MAKE_DEF_FILE |
202 } |
207 } |
203 |
208 |
204 |
209 |
205 EXPORT_C TInt HCR::GetInt(const TSettingId& aId, TInt16& aValue) |
210 EXPORT_C TInt HCR::GetInt(const TSettingId& aId, TInt16& aValue) |
208 HCR_FUNC("HCR::GetInt16"); |
213 HCR_FUNC("HCR::GetInt16"); |
209 |
214 |
210 UValueWord value; |
215 UValueWord value; |
211 TInt err = GetUValueWordSetting(aId, ETypeInt16, value); |
216 TInt err = GetUValueWordSetting(aId, ETypeInt16, value); |
212 if (err != KErrNone) |
217 if (err != KErrNone) |
213 HCR_LOG_RETURN(err); |
218 HCR_TRACE_RETURN(err); |
214 |
219 |
215 aValue = value.iInt16; |
220 aValue = value.iInt16; |
216 return KErrNone; |
221 return KErrNone; |
217 #else |
222 #else |
218 return KErrNotSupported; |
223 HCR_TRACE_RETURN(KErrGeneral); |
219 #endif // MAKE_DEF_FILE |
224 #endif // MAKE_DEF_FILE |
220 } |
225 } |
221 |
226 |
222 |
227 |
223 EXPORT_C TInt HCR::GetInt(const TSettingId& aId, TInt32& aValue) |
228 EXPORT_C TInt HCR::GetInt(const TSettingId& aId, TInt32& aValue) |
226 HCR_FUNC("HCR::GetInt32"); |
231 HCR_FUNC("HCR::GetInt32"); |
227 |
232 |
228 UValueWord value; |
233 UValueWord value; |
229 TInt err = GetUValueWordSetting(aId, ETypeInt32, value); |
234 TInt err = GetUValueWordSetting(aId, ETypeInt32, value); |
230 if (err != KErrNone) |
235 if (err != KErrNone) |
231 HCR_LOG_RETURN(err); |
236 HCR_TRACE_RETURN(err); |
232 |
237 |
233 aValue = value.iInt32; |
238 aValue = value.iInt32; |
234 return KErrNone; |
239 return KErrNone; |
235 #else |
240 #else |
236 return KErrNotSupported; |
241 HCR_TRACE_RETURN(KErrGeneral); |
237 #endif // MAKE_DEF_FILE |
242 #endif // MAKE_DEF_FILE |
238 } |
243 } |
239 |
244 |
240 |
245 |
241 EXPORT_C TInt HCR::GetInt(const TSettingId& aId, TInt64& aValue) |
246 EXPORT_C TInt HCR::GetInt(const TSettingId& aId, TInt64& aValue) |
244 HCR_FUNC("HCR::GetInt64"); |
249 HCR_FUNC("HCR::GetInt64"); |
245 |
250 |
246 UValueLarge value; |
251 UValueLarge value; |
247 TInt err = GetUValueLargeSetting64(aId, ETypeInt64, value); |
252 TInt err = GetUValueLargeSetting64(aId, ETypeInt64, value); |
248 if (err != KErrNone) |
253 if (err != KErrNone) |
249 HCR_LOG_RETURN(err); |
254 HCR_TRACE_RETURN(err); |
250 |
255 |
251 aValue = *(value.iInt64); |
256 aValue = *(value.iInt64); |
252 return KErrNone; |
257 return KErrNone; |
253 #else |
258 #else |
254 return KErrNotSupported; |
259 HCR_TRACE_RETURN(KErrGeneral); |
255 #endif // MAKE_DEF_FILE |
260 #endif // MAKE_DEF_FILE |
256 } |
261 } |
257 |
262 |
258 |
263 |
259 EXPORT_C TInt HCR::GetBool(const TSettingId& aId, TBool& aValue) |
264 EXPORT_C TInt HCR::GetBool(const TSettingId& aId, TBool& aValue) |
262 HCR_FUNC("HCR::GetBool"); |
267 HCR_FUNC("HCR::GetBool"); |
263 |
268 |
264 UValueWord value; |
269 UValueWord value; |
265 TInt err = GetUValueWordSetting(aId, ETypeBool, value); |
270 TInt err = GetUValueWordSetting(aId, ETypeBool, value); |
266 if (err != KErrNone) |
271 if (err != KErrNone) |
267 HCR_LOG_RETURN(err); |
272 HCR_TRACE_RETURN(err); |
268 |
273 |
269 aValue = value.iBool; |
274 aValue = value.iBool; |
270 return KErrNone; |
275 return KErrNone; |
271 #else |
276 #else |
272 return KErrNotSupported; |
277 HCR_TRACE_RETURN(KErrGeneral); |
273 #endif // MAKE_DEF_FILE |
278 #endif // MAKE_DEF_FILE |
274 } |
279 } |
275 |
280 |
276 |
281 |
277 EXPORT_C TInt HCR::GetUInt(const TSettingId& aId, TUint8& aValue) |
282 EXPORT_C TInt HCR::GetUInt(const TSettingId& aId, TUint8& aValue) |
280 HCR_FUNC("HCR::GetUInt8"); |
285 HCR_FUNC("HCR::GetUInt8"); |
281 |
286 |
282 UValueWord value; |
287 UValueWord value; |
283 TInt err = GetUValueWordSetting(aId, ETypeUInt8, value); |
288 TInt err = GetUValueWordSetting(aId, ETypeUInt8, value); |
284 if (err != KErrNone) |
289 if (err != KErrNone) |
285 HCR_LOG_RETURN(err); |
290 HCR_TRACE_RETURN(err); |
286 |
291 |
287 aValue = value.iUInt8; |
292 aValue = value.iUInt8; |
288 return KErrNone; |
293 return KErrNone; |
289 #else |
294 #else |
290 return KErrNotSupported; |
295 HCR_TRACE_RETURN(KErrGeneral); |
291 #endif // MAKE_DEF_FILE |
296 #endif // MAKE_DEF_FILE |
292 } |
297 } |
293 |
298 |
294 |
299 |
295 EXPORT_C TInt HCR::GetUInt(const TSettingId& aId, TUint16& aValue) |
300 EXPORT_C TInt HCR::GetUInt(const TSettingId& aId, TUint16& aValue) |
298 HCR_FUNC("HCR::GetUInt16"); |
303 HCR_FUNC("HCR::GetUInt16"); |
299 |
304 |
300 UValueWord value; |
305 UValueWord value; |
301 TInt err = GetUValueWordSetting(aId, ETypeUInt16,value); |
306 TInt err = GetUValueWordSetting(aId, ETypeUInt16,value); |
302 if (err != KErrNone) |
307 if (err != KErrNone) |
303 HCR_LOG_RETURN(err); |
308 HCR_TRACE_RETURN(err); |
304 |
309 |
305 aValue = value.iUInt16; |
310 aValue = value.iUInt16; |
306 return KErrNone; |
311 return KErrNone; |
307 #else |
312 #else |
308 return KErrNotSupported; |
313 HCR_TRACE_RETURN(KErrGeneral); |
309 #endif // MAKE_DEF_FILE |
314 #endif // MAKE_DEF_FILE |
310 } |
315 } |
311 |
316 |
312 |
317 |
313 EXPORT_C TInt HCR::GetUInt(const TSettingId& aId, TUint32& aValue) |
318 EXPORT_C TInt HCR::GetUInt(const TSettingId& aId, TUint32& aValue) |
316 HCR_FUNC("HCR::GetUInt32"); |
321 HCR_FUNC("HCR::GetUInt32"); |
317 |
322 |
318 UValueWord value; |
323 UValueWord value; |
319 TInt err = GetUValueWordSetting(aId, ETypeUInt32, value); |
324 TInt err = GetUValueWordSetting(aId, ETypeUInt32, value); |
320 if (err != KErrNone) |
325 if (err != KErrNone) |
321 HCR_LOG_RETURN(err); |
326 HCR_TRACE_RETURN(err); |
322 |
327 |
323 aValue = value.iUInt32; |
328 aValue = value.iUInt32; |
324 return KErrNone; |
329 return KErrNone; |
325 #else |
330 #else |
326 return KErrNotSupported; |
331 HCR_TRACE_RETURN(KErrGeneral); |
327 #endif // MAKE_DEF_FILE |
332 #endif // MAKE_DEF_FILE |
328 } |
333 } |
329 |
334 |
330 |
335 |
331 EXPORT_C TInt HCR::GetUInt(const TSettingId& aId, TUint64& aValue) |
336 EXPORT_C TInt HCR::GetUInt(const TSettingId& aId, TUint64& aValue) |
334 HCR_FUNC("HCR::GetUInt64"); |
339 HCR_FUNC("HCR::GetUInt64"); |
335 |
340 |
336 UValueLarge value; |
341 UValueLarge value; |
337 TInt err = GetUValueLargeSetting64(aId, ETypeUInt64, value); |
342 TInt err = GetUValueLargeSetting64(aId, ETypeUInt64, value); |
338 if (err != KErrNone) |
343 if (err != KErrNone) |
339 HCR_LOG_RETURN(err); |
344 HCR_TRACE_RETURN(err); |
340 |
345 |
341 aValue = *(value.iUInt64); |
346 aValue = *(value.iUInt64); |
342 return KErrNone; |
347 return KErrNone; |
343 #else |
348 #else |
344 return KErrNotSupported; |
349 HCR_TRACE_RETURN(KErrGeneral); |
345 #endif // MAKE_DEF_FILE |
350 #endif // MAKE_DEF_FILE |
346 } |
351 } |
347 |
352 |
348 |
353 |
349 EXPORT_C TInt HCR::GetLinAddr(const TSettingId& aId, TLinAddr& aValue) |
354 EXPORT_C TInt HCR::GetLinAddr(const TSettingId& aId, TLinAddr& aValue) |
352 HCR_FUNC("HCR::GetLinAddr"); |
357 HCR_FUNC("HCR::GetLinAddr"); |
353 |
358 |
354 UValueWord value; |
359 UValueWord value; |
355 TInt err = GetUValueWordSetting(aId, ETypeLinAddr, value); |
360 TInt err = GetUValueWordSetting(aId, ETypeLinAddr, value); |
356 if (err != KErrNone) |
361 if (err != KErrNone) |
357 HCR_LOG_RETURN(err); |
362 HCR_TRACE_RETURN(err); |
358 |
363 |
359 aValue = value.iAddress; |
364 aValue = value.iAddress; |
360 return KErrNone; |
365 return KErrNone; |
361 #else |
366 #else |
362 return KErrNotSupported; |
367 HCR_TRACE_RETURN(KErrGeneral); |
363 #endif // MAKE_DEF_FILE |
368 #endif // MAKE_DEF_FILE |
364 } |
369 } |
365 |
370 |
366 |
371 |
367 EXPORT_C TInt HCR::GetData(const TSettingId& aId, TUint16 aMaxLen, |
372 EXPORT_C TInt HCR::GetData(const TSettingId& aId, TUint16 aMaxLen, |
370 #ifndef MAKE_DEF_FILE |
375 #ifndef MAKE_DEF_FILE |
371 HCR_FUNC("HCR::GetDataTUint8"); |
376 HCR_FUNC("HCR::GetDataTUint8"); |
372 |
377 |
373 TInt err = GetUValueLargeSettingTUint8(aId, ETypeBinData, aMaxLen, aValue, aLen); |
378 TInt err = GetUValueLargeSettingTUint8(aId, ETypeBinData, aMaxLen, aValue, aLen); |
374 if (err != KErrNone) |
379 if (err != KErrNone) |
375 HCR_LOG_RETURN(err); |
380 HCR_TRACE_RETURN(err); |
376 |
381 |
377 return KErrNone; |
382 return KErrNone; |
378 #else |
383 #else |
379 return KErrNotSupported; |
384 HCR_TRACE_RETURN(KErrGeneral); |
380 #endif // MAKE_DEF_FILE |
385 #endif // MAKE_DEF_FILE |
381 } |
386 } |
382 |
387 |
383 |
388 |
384 EXPORT_C TInt HCR::GetData(const TSettingId& aId, TDes8& aValue) |
389 EXPORT_C TInt HCR::GetData(const TSettingId& aId, TDes8& aValue) |
386 #ifndef MAKE_DEF_FILE |
391 #ifndef MAKE_DEF_FILE |
387 HCR_FUNC("HCR::GetDataTDes8"); |
392 HCR_FUNC("HCR::GetDataTDes8"); |
388 |
393 |
389 TInt err = GetUValueLargeSettingTDes8(aId, ETypeBinData, aValue); |
394 TInt err = GetUValueLargeSettingTDes8(aId, ETypeBinData, aValue); |
390 if (err != KErrNone) |
395 if (err != KErrNone) |
391 HCR_LOG_RETURN(err); |
396 HCR_TRACE_RETURN(err); |
392 |
397 |
393 return KErrNone; |
398 return KErrNone; |
394 #else |
399 #else |
395 return KErrNotSupported; |
400 HCR_TRACE_RETURN(KErrGeneral); |
396 #endif // MAKE_DEF_FILE |
401 #endif // MAKE_DEF_FILE |
397 } |
402 } |
398 |
403 |
399 |
404 |
400 EXPORT_C TInt HCR::GetString(const TSettingId& aId, TUint16 aMaxLen, |
405 EXPORT_C TInt HCR::GetString(const TSettingId& aId, TUint16 aMaxLen, |
403 #ifndef MAKE_DEF_FILE |
408 #ifndef MAKE_DEF_FILE |
404 HCR_FUNC("HCR::GetStringTUint8"); |
409 HCR_FUNC("HCR::GetStringTUint8"); |
405 |
410 |
406 TInt err = GetUValueLargeSettingTUint8(aId, ETypeText8, aMaxLen, aValue, aLen); |
411 TInt err = GetUValueLargeSettingTUint8(aId, ETypeText8, aMaxLen, aValue, aLen); |
407 if (err != KErrNone) |
412 if (err != KErrNone) |
408 HCR_LOG_RETURN(err); |
413 HCR_TRACE_RETURN(err); |
409 |
414 |
410 return KErrNone; |
415 return KErrNone; |
411 #else |
416 #else |
412 return KErrNotSupported; |
417 HCR_TRACE_RETURN(KErrGeneral); |
413 #endif // MAKE_DEF_FILE |
418 #endif // MAKE_DEF_FILE |
414 } |
419 } |
415 |
420 |
416 |
421 |
417 EXPORT_C TInt HCR::GetString(const TSettingId& aId, TDes8& aValue) |
422 EXPORT_C TInt HCR::GetString(const TSettingId& aId, TDes8& aValue) |
419 #ifndef MAKE_DEF_FILE |
424 #ifndef MAKE_DEF_FILE |
420 HCR_FUNC("HCR::GetStringTUint8"); |
425 HCR_FUNC("HCR::GetStringTUint8"); |
421 |
426 |
422 TInt err = GetUValueLargeSettingTDes8(aId, ETypeText8, aValue); |
427 TInt err = GetUValueLargeSettingTDes8(aId, ETypeText8, aValue); |
423 if (err != KErrNone) |
428 if (err != KErrNone) |
424 HCR_LOG_RETURN(err); |
429 HCR_TRACE_RETURN(err); |
425 |
430 |
426 return KErrNone; |
431 return KErrNone; |
427 #else |
432 #else |
428 return KErrNotSupported; |
433 HCR_TRACE_RETURN(KErrGeneral); |
429 #endif // MAKE_DEF_FILE |
434 #endif // MAKE_DEF_FILE |
430 } |
435 } |
431 |
436 |
432 EXPORT_C TInt HCR::GetArray(const TSettingId& aId, TUint16 aMaxLen, |
437 EXPORT_C TInt HCR::GetArray(const TSettingId& aId, TUint16 aMaxLen, |
433 TInt32* aValue, TUint16& aLen) |
438 TInt32* aValue, TUint16& aLen) |
435 #ifndef MAKE_DEF_FILE |
440 #ifndef MAKE_DEF_FILE |
436 HCR_FUNC("HCR::GetArrayTInt32"); |
441 HCR_FUNC("HCR::GetArrayTInt32"); |
437 |
442 |
438 TInt err = GetUValueLargeSettingArray(aId, ETypeArrayInt32, aMaxLen, (TUint32*)aValue, aLen); |
443 TInt err = GetUValueLargeSettingArray(aId, ETypeArrayInt32, aMaxLen, (TUint32*)aValue, aLen); |
439 if (err != KErrNone) |
444 if (err != KErrNone) |
440 HCR_LOG_RETURN(err); |
445 HCR_TRACE_RETURN(err); |
441 |
446 |
442 return KErrNone; |
447 return KErrNone; |
443 #else |
448 #else |
444 return KErrNotSupported; |
449 HCR_TRACE_RETURN(KErrGeneral); |
445 #endif // MAKE_DEF_FILE |
450 #endif // MAKE_DEF_FILE |
446 } |
451 } |
447 |
452 |
448 EXPORT_C TInt HCR::GetArray(const TSettingId& aId, TUint16 aMaxLen, |
453 EXPORT_C TInt HCR::GetArray(const TSettingId& aId, TUint16 aMaxLen, |
449 TUint32* aValue, TUint16& aLen) |
454 TUint32* aValue, TUint16& aLen) |
451 #ifndef MAKE_DEF_FILE |
456 #ifndef MAKE_DEF_FILE |
452 HCR_FUNC("HCR::GetArrayTUInt32"); |
457 HCR_FUNC("HCR::GetArrayTUInt32"); |
453 |
458 |
454 TInt err = GetUValueLargeSettingArray(aId, ETypeArrayUInt32, aMaxLen, aValue, aLen); |
459 TInt err = GetUValueLargeSettingArray(aId, ETypeArrayUInt32, aMaxLen, aValue, aLen); |
455 if (err != KErrNone) |
460 if (err != KErrNone) |
456 HCR_LOG_RETURN(err); |
461 HCR_TRACE_RETURN(err); |
457 |
462 |
458 return KErrNone; |
463 return KErrNone; |
459 #else |
464 #else |
460 return KErrNotSupported; |
465 HCR_TRACE_RETURN(KErrGeneral); |
461 #endif // MAKE_DEF_FILE |
466 #endif // MAKE_DEF_FILE |
462 } |
467 } |
463 |
468 |
464 |
469 |
465 // -- MULTIPLE GETS ----------------------------------------------------------- |
470 // -- MULTIPLE GETS ----------------------------------------------------------- |
466 |
471 |
467 EXPORT_C TInt HCR::GetWordSettings(TInt /*aNum*/, const SSettingId /*aIds*/[], |
472 EXPORT_C TInt HCR::GetWordSettings(TInt aNum, const SSettingId aIds[], |
468 TInt32 /*aValues*/[], TSettingType /*aTypes*/[], TInt /*aErrors*/[]) |
473 TInt32 aValues[], TSettingType aTypes[], TInt aErrors[]) |
469 { |
474 { |
470 #ifndef MAKE_DEF_FILE |
475 |
471 |
476 #ifndef MAKE_DEF_FILE |
472 return KErrNotSupported; |
477 HCR_FUNC("GetWordSettings"); |
473 #else |
478 |
474 return KErrNotSupported; |
479 if (HCRNotReady) |
480 HCR_TRACE_RETURN(KErrNotReady); |
|
481 |
|
482 if(aNum <= 0 || aIds == NULL || aErrors == NULL || aValues == NULL) |
|
483 HCR_TRACE_RETURN(KErrArgument); |
|
484 |
|
485 TInt err = KErrNone; |
|
486 |
|
487 //Don't leave while the resources are not fully allocated/deallocated |
|
488 NKern::ThreadEnterCS(); |
|
489 |
|
490 err = HCRSingleton->GetWordSettings(aNum, aIds, aValues, aTypes, aErrors); |
|
491 |
|
492 //All de-allocations are done, leave a critical section |
|
493 NKern::ThreadLeaveCS(); |
|
494 |
|
495 if(err < KErrNone) |
|
496 HCR_TRACE_RETURN(err); |
|
497 |
|
498 return err; |
|
499 |
|
500 #else |
|
501 HCR_TRACE_RETURN(KErrGeneral); |
|
475 #endif // MAKE_DEF_FILE |
502 #endif // MAKE_DEF_FILE |
476 } |
503 } |
477 |
504 |
478 |
505 |
479 // -- SETTING PROPERTIES ------------------------------------------------------ |
506 // -- SETTING PROPERTIES ------------------------------------------------------ |
480 |
507 |
481 EXPORT_C TInt HCR::GetTypeAndSize(const TSettingId& /*aId*/, TSettingType& /*aType*/, |
508 EXPORT_C TInt HCR::GetTypeAndSize(const TSettingId& aId, TSettingType& aType, |
482 TUint16& /*aLen*/) |
509 TUint16& aLen) |
483 { |
510 { |
484 #ifndef MAKE_DEF_FILE |
511 #ifndef MAKE_DEF_FILE |
485 |
512 HCR_FUNC("GetTypeAndSize"); |
486 return KErrNotSupported; |
513 if (HCRNotReady) |
487 #else |
514 HCR_TRACE_RETURN(KErrNotReady); |
488 return KErrNotSupported; |
515 |
489 #endif // MAKE_DEF_FILE |
516 TSettingRef sref(0,0); |
517 TInt err = HCRSingleton->FindSettingWithType(aId, aType, sref); |
|
518 |
|
519 if(err == KErrNone) |
|
520 { |
|
521 aLen = sref.iRep->GetLength(sref); |
|
522 } |
|
523 else if(err == KErrNotFound) |
|
524 { |
|
525 aLen = 0; |
|
526 HCR_TRACE_RETURN(KErrNotFound); |
|
527 } |
|
528 else |
|
529 HCR_TRACE_RETURN(err); |
|
530 |
|
531 return KErrNone; |
|
532 |
|
533 #else |
|
534 HCR_TRACE_RETURN(KErrGeneral); |
|
535 #endif //MAKE_DEF_FILE |
|
490 } |
536 } |
491 |
537 |
492 |
538 |
493 // -- SETTING SEARCHES -------------------------------------------------------- |
539 // -- SETTING SEARCHES -------------------------------------------------------- |
494 |
540 |
495 EXPORT_C TInt HCR::FindNumSettingsInCategory (TCategoryUid /*aCatUid*/) |
541 EXPORT_C TInt HCR::FindNumSettingsInCategory (TCategoryUid aCatUid) |
496 { |
542 { |
497 #ifndef MAKE_DEF_FILE |
543 #ifndef MAKE_DEF_FILE |
498 |
544 |
499 return KErrNotSupported; |
545 HCR_FUNC("FindNumSettingsInCategory"); |
500 #else |
546 |
501 return KErrNotSupported; |
547 if (HCRNotReady) |
502 #endif // MAKE_DEF_FILE |
548 HCR_TRACE_RETURN(KErrNotReady); |
503 } |
549 |
504 |
550 TInt err = HCRSingleton->FindNumSettingsInCategory(aCatUid); |
505 EXPORT_C TInt HCR::FindSettings(TCategoryUid /*aCatUid*/, |
551 |
506 TInt /*aMaxNum*/, TUint32& /*aNumFound*/, |
552 if(err < 0) |
507 TElementId* /*aElIds*/, TSettingType* /*aTypes*/, TUint16* /*aLens*/) |
553 HCR_TRACE_RETURN(err); |
554 |
|
555 return err; |
|
556 |
|
557 #else |
|
558 HCR_TRACE_RETURN(KErrGeneral); |
|
559 #endif // MAKE_DEF_FILE |
|
560 } |
|
561 |
|
562 |
|
563 EXPORT_C TInt HCR::FindSettings(TCategoryUid aCat, TInt aMaxNum, |
|
564 TElementId aElIds[], TSettingType aTypes[], TUint16 aLens[]) |
|
508 { |
565 { |
509 #ifndef MAKE_DEF_FILE |
566 #ifndef MAKE_DEF_FILE |
510 |
567 |
511 return KErrNotSupported; |
568 HCR_FUNC("FindSettings without pattern/mask"); |
512 #else |
569 |
513 return KErrNotSupported; |
570 |
514 #endif // MAKE_DEF_FILE |
571 if (HCRNotReady) |
515 } |
572 HCR_TRACE_RETURN(KErrNotReady); |
516 |
573 |
517 EXPORT_C TInt HCR::FindSettings(TCategoryUid /*aCat*/, |
574 if(aMaxNum <= 0 || aElIds == NULL) |
518 TInt /*aMaxNum*/, TUint32 /*aAtId*/, |
575 HCR_TRACE_RETURN(KErrArgument); |
519 TUint32 /*aMask*/, TUint32 /*aPattern*/, TUint32& /*aNumFound*/, |
576 |
520 TElementId* /*aElIds*/, TSettingType* /*aTypes*/, TUint16* /*aLens*/) |
577 TInt err = HCRSingleton->FindSettings(aCat, aMaxNum, aElIds, |
578 aTypes, aLens); |
|
579 |
|
580 if(err < 0) |
|
581 HCR_TRACE_RETURN(err); |
|
582 |
|
583 return err; |
|
584 |
|
585 #else |
|
586 HCR_TRACE_RETURN(KErrGeneral); |
|
587 #endif // MAKE_DEF_FILE |
|
588 } |
|
589 |
|
590 EXPORT_C TInt HCR::FindSettings(TCategoryUid aCat, |
|
591 TInt aMaxNum, TUint32 aMask, TUint32 aPattern, |
|
592 TElementId aElIds[], TSettingType aTypes[], TUint16 aLens[]) |
|
521 { |
593 { |
522 #ifndef MAKE_DEF_FILE |
594 #ifndef MAKE_DEF_FILE |
523 |
595 |
524 return KErrNotSupported; |
596 HCR_FUNC("FindSettings with pattern/mask"); |
525 #else |
597 |
526 return KErrNotSupported; |
598 |
599 if (HCRNotReady) |
|
600 HCR_TRACE_RETURN(KErrNotReady); |
|
601 |
|
602 if(aMaxNum <= 0 || aElIds == NULL) |
|
603 HCR_TRACE_RETURN(KErrArgument); |
|
604 |
|
605 TInt err = KErrNone; |
|
606 |
|
607 //Don't leave while the resources are not fully allocated/deallocated |
|
608 NKern::ThreadEnterCS(); |
|
609 |
|
610 err = HCRSingleton->FindSettings(aCat, aMaxNum, aMask, aPattern, |
|
611 aElIds, aTypes, aLens); |
|
612 |
|
613 //All de-allocations are done, leave a critical section |
|
614 NKern::ThreadLeaveCS(); |
|
615 |
|
616 if(err < 0) |
|
617 HCR_TRACE_RETURN(err); |
|
618 |
|
619 return err; |
|
620 |
|
621 #else |
|
622 HCR_TRACE_RETURN(KErrGeneral); |
|
527 #endif // MAKE_DEF_FILE |
623 #endif // MAKE_DEF_FILE |
528 } |
624 } |
529 |
625 |
530 |
626 |
531 // -- KERNEL ENTRY POINT ------------------------------------------------------ |
627 // -- KERNEL ENTRY POINT ------------------------------------------------------ |