关于来电拦截，到目前最全版本的

1. 因为涉及到三版和二版两个版本的API，所以我先发个二版的（其实也就是来电检测不同），要用到的能力有 NetworkControl，NetworkServices，ReadUserData，SwEvent，WriteDeviceData
   下面是H文件
2. 
   
3. /*
   
4. * CTelDial.h
   
5. *
   
6. *  Created on: 2009年9月18日
   
7. *      Author: snowind
   
8. */
   
9. 
   
10. #ifndef CTELDIAL_H_
    
11. #define CTELDIAL_H_
    
12. 
    
13. //etel core api
    
14. #include
    
15. #include
    
16. 
    
17. #include
    
18. 
    
19. //for the vibra and ring
    
20. #include
    
21. #include
    
22. #include
    
23. #include
    
24. 
    
25. #include //CR Keys To Control Phone Volume
    
26. #include //CRepository
    
27. 
    
28. //for the light
    
29. #include
    
30. 
    
31. //for the loud speaker
    
32. #include
    
33. #include
    
34. 
    
35. //simulation key
    
36. #include
    
37. 
    
38. class CTelDial: public CActive
    
39.         {
    
40. public:
    
41.         
    
42.         static CTelDial* NewL();
    
43.                
    
44.         void GetDefaultTSY(TDes& aTSYName);
    
45.         
    
46.         void StartObserve();
    
47. 
    
48.         //the dial
    
49.         
    
50.         void GetDialNumber();
    
51.         
    
52.         void SetDialNumber(const TDes& aSetDialNumber);
    
53.         
    
54.         bool CmpDialedNumber();
    
55.         
    
56.         void OpenLoudSpeaker();
    
57.         
    
58.         void SetCallVolumn(const TInt aspeakvol);
    
59.         
    
60.         //the receive
    
61. 
    
62.         void GetReceivedNumber();
    
63.         
    
64.         void SetReceiveNumber(const TDes& aSetReceiveNumber);
    
65.         
    
66.         bool CmpReceivedNumber();
    
67.         
    
68.         //detect        
    
69.         
    
70.         void SetDetectNumber(const TDes& aSetDetectNumber);        
    
71.         
    
72.         bool CmpDetectNumber();
    
73.         
    
74.         //light and vibra
    
75.         
    
76.         void SetVibraAndRing();
    
77.         
    
78.         void RecoverVibraAndRing();
    
79.         
    
80.         //simulate key
    
81.         
    
82.         void SimulateRedKey();
    
83.         
    
84.         void SimulateRightKey();
    
85.         
    
86.         //release
    
87.         
    
88.         void ReleaseOneCall();
    
89.         
    
90.         ~CTelDial();
    
91.         
    
92. protected:
    
93.         
    
94.         void RunL();
    
95.         
    
96.         void DoCancel();
    
97.         
    
98. private:
    
99.         
    
100.         CTelDial();
     
101.                
     
102.         void ConstructL();
     
103.         
     
104.         static CTelDial* NewLC();
     
105.         
     
106. private:
     
107.         //const TUid KUidSound =0x101f8798;
     
108. //Etel Api
     
109. private:
     
110.         
     
111.         TBuf <20>iTSYName;
     
112.         RTelServer iServer;
     
113.         RPhone iPhone;
     
114.         RPhone::TLineInfo iphonelineinfo;
     
115.         RLine iLine;
     
116.         RLine::TLineInfo ilineinfo;
     
117.         RCall::TStatus iCallStatus;
     
118.         //from the etelmm
     
119.         RMobileCall iMCall;
     
120. 
     
121. //the numbers
     
122. private:
     
123.         TBuf <11> iNumberDial;
     
124.         TBuf <11> iNumberReceive;
     
125.         TBuf <11> iNumberDialSet;
     
126.         TBuf <11> iNumberReceiveSet;
     
127.         TBuf <11> iNumberDetectSet;
     
128. 
     
129. //to change the repository
     
130. private:
     
131.         CRepository* irepository;
     
132. 
     
133.         
     
134. //for the vibra and ring
     
135. private:
     
136.         TBool ivibratype;
     
137.         TProfileRingingType iRingingType;
     
138.         
     
139. private:
     
140.         CHWRMLight* ilight;
     
141.         
     
142. private:
     
143.         RWindowGroup iwindowgroup;
     
144.         
     
145. //simulate key
     
146. private:
     
147.         RWsSession ws;
     
148.         TRawEvent ev1;
     
149.         
     
150.         
     
151.         };
     
152. 
     
153. #endif /* CTELDIAL_H_ */

因为电话挂断有两种方法，所我先发所有的函数申明，然后再发不同的地方

1. /*
   
2. * CTelDial.cpp
   
3. *
   
4. *  Created on: 2009年9月18日
   
5. *      Author: snowind
   
6. */
   
7. 
   
8. #include
   
9. #include
   
10. #include "CTelDial.h"
    
11. 
    
12. //constructed function
    
13. void CTelDial::ConstructL()
    
14.         {
    
15.         //add the cteldial to the active scheduler
    
16.         CActiveScheduler::Add(this);
    
17. 
    
18.         ilight = CHWRMLight::NewL();
    
19.        
    
20. 
    
21.         //use the etel core api
    
22.         //create a tel server
    
23.         User::LeaveIfError(iServer.Connect()); //connect
    
24. 
    
25.         //get the number of phones in the server
    
26.         TInt numberphones;
    
27.         User::LeaveIfError(iServer.EnumeratePhones(numberphones));
    
28. 
    
29.         //get the default tsy
    
30.         GetDefaultTSY(iTSYName);
    
31. 
    
32.         //load the tsy module
    
33.         User::LeaveIfError(iServer.LoadPhoneModule(iTSYName));
    
34. 
    
35.         //get the first phone's info
    
36.         RTelServer::TPhoneInfo iPhoneinfo;
    
37.         User::LeaveIfError(iServer.GetPhoneInfo(0, iPhoneinfo));
    
38. 
    
39.         //use this info to connect the phone
    
40.         User::LeaveIfError(iPhone.Open(iServer, iPhoneinfo.iName));
    
41.         iPhone.Initialise();
    
42. 
    
43.         //get the number of line
    
44.         TInt numberline;
    
45.         User::LeaveIfError(iPhone.EnumerateLines(numberline));
    
46.         User::LeaveIfError(iPhone.GetLineInfo(0, iphonelineinfo));
    
47.         User::LeaveIfError(iLine.Open(iPhone, iphonelineinfo.iName));
    
48.         }
    
49. 
    
50. //----------------------------------------------------
    
51. //CTelDial::StartObserve()
    
52. //observe the call
    
53. //----------------------------------------------------
    
54. void CTelDial::StartObserve()
    
55.         {
    
56.         Cancel();
    
57. 
    
58.         //if the status of line changes, it means some one is calling this phone
    
59.         iLine.NotifyStatusChange(iStatus, iCallStatus);
    
60. 
    
61.         //invoke the asynchronous function
    
62.         SetActive();
    
63.         }
    
64. 
    
65. 
    
66. 
    
67. //----------------------------------------------------
    
68. //CTelDial::SetVibraAndRing()
    
69. //turn off the vibra and ring
    
70. //----------------------------------------------------
    
71. void CTelDial::SetVibraAndRing()
    
72.         {
    
73.         MProEngEngine* iEngine = ProEngFactory::NewEngineL();
    
74.         MProEngProfile* iProfile = iEngine->ActiveProfileLC();
    
75.         MProEngToneSettings& iToneSetting = iProfile->ToneSettings();
    
76. 
    
77.         //get the status of vibra, if vibra is on, turn off it
    
78.         ivibratype = iToneSetting.VibratingAlert();
    
79.         if (ivibratype)
    
80.                 {
    
81.                 iToneSetting.SetVibratingAlert(EFalse);
    
82.                 }
    
83. 
    
84.         //get the status of vibra, turn off the ring
    
85.         iRingingType = iToneSetting.RingingType();
    
86.         if (EProfileRingingTypeSilent != iRingingType)
    
87.                 {
    
88.                 iToneSetting.SetRingingType(EProfileRingingTypeSilent);
    
89.                 }
    
90.        
    
91.         //execute the orders
    
92.         iProfile->CommitChangeL();
    
93. 
    
94.         //must release the MPorEngProfile and MProEngEngine everytime
    
95.         iProfile->Release();
    
96.         iEngine->Release();
    
97.         }
    
98. 
    
99. //----------------------------------------------------
    
100. //CTelDial::RecoverVibraAndRing()
     
101. //recover the vibra and ring
     
102. //----------------------------------------------------
     
103. void CTelDial::RecoverVibraAndRing()
     
104.         {
     
105.         MProEngEngine* iEngine = ProEngFactory::NewEngineL();
     
106.         MProEngProfile* iProfile = iEngine->ActiveProfileLC();
     
107.         MProEngToneSettings& iToneSetting = iProfile->ToneSettings();
     
108. 
     
109.         //recover
     
110.         iToneSetting.SetVibratingAlert(ivibratype);
     
111.         iToneSetting.SetRingingType(iRingingType);
     
112. 
     
113.         iProfile->CommitChangeL();
     
114. 
     
115.         iProfile->Release();
     
116.         iEngine->Release();
     
117.         }
     
118. 
     
119. void CTelDial::ReleaseOneCall()
     
120.         {
     
121.         iMCall.Close();
     
122.        
     
123.         }
     
124. 
     
125. //----------------------------------------------------
     
126. //CTelDial::GetReceivedNumber()
     
127. //get the incoming call number
     
128. //----------------------------------------------------
     
129. void CTelDial::GetReceivedNumber()
     
130.         {
     
131.         //for the etelmm in the 2nd
     
132.         //for the incoming call number
     
133.         TInt theerr;
     
134.         RMobileCall::TMobileCallInfoV1 remotePartyInfo;
     
135.         RMobileCall::TMobileCallInfoV1Pckg remotePartyInfopckg(remotePartyInfo);
     
136. 
     
137.         //this is the key place, at first, the solution from wiki
     
138.         //of nokia official website is below:
     
139.         //the two functions are:
     
140.         //User::LeaveIfError(theerr = iLine.GetCallInfo(0, ilinecallinfo));
     
141.         //User::LeaveIfError(theerr = iCall.OpenExistingCall(iLine, ilinecallinfo.iCallName));
     
142.         //however, those are wrong, the correct solution is below:
     
143.         User::LeaveIfError(theerr = iLine.GetInfo(ilineinfo));
     
144. 
     
145.         User::LeaveIfError(theerr = iMCall.OpenExistingCall(iLine,
     
146.                         ilineinfo.iNameOfCallForAnswering));
     
147. 
     
148.         User::LeaveIfError(theerr = iMCall.GetMobileCallInfo(remotePartyInfopckg));
     
149. 
     
150.         // Tried this also - telNumber.Append(iRemotePartyInfo.iRemoteParty.iRemoteNumber.iTelNumber);
     
151.         iNumberReceive.Copy(remotePartyInfopckg().iRemoteParty.iRemoteNumber.iTelNumber);
     
152.         //iNumberDial.Copy(remotePartyInfo.iDialledParty.iTelNumber);
     
153.         //this is also OK
     
154. }
     
155. 
     
156. //----------------------------------------------------
     
157. //CTelDial::GetDialNumber()
     
158. //get the outgoing call number
     
159. //----------------------------------------------------
     
160. void CTelDial::GetDialNumber()
     
161.         {
     
162.         //for the etelmm in the 2nd
     
163.         //for the outgoing call number
     
164.         TInt theerr;
     
165.         RMobileCall::TMobileCallInfoV1 remotePartyInfo;
     
166.         RMobileCall::TMobileCallInfoV1Pckg remotePartyInfopckg(remotePartyInfo);
     
167. 
     
168.         //this is the key place, at first, the solution from wiki
     
169.         //of nokia official website is below:
     
170.         //the two functions are:
     
171.         //User::LeaveIfError(theerr = iLine.GetCallInfo(0, ilinecallinfo));
     
172.         //User::LeaveIfError(theerr = iCall.OpenExistingCall(iLine, ilinecallinfo.iCallName));
     
173.         //however, those are wrong, the correct solution is below:
     
174.         User::LeaveIfError(theerr = iLine.GetInfo(ilineinfo));
     
175. 
     
176.         User::LeaveIfError(theerr = iMCall.OpenExistingCall(iLine,
     
177.                         ilineinfo.iNameOfLastCallAdded));
     
178. 
     
179.         User::LeaveIfError(theerr = iMCall.GetMobileCallInfo(remotePartyInfopckg));
     
180. 
     
181.         // Tried this also - telNumber.Append(iRemotePartyInfo.iRemoteParty.iRemoteNumber.iTelNumber);
     
182.         iNumberDial.Copy(remotePartyInfopckg().iDialledParty.iTelNumber);
     
183.         //this is also OK  iNumberDial.Copy(remotePartyInfo.iDialledParty.iTelNumber);
     
184.         }
     
185. 
     
186. bool CTelDial::CmpDialedNumber()
     
187.         {
     
188.         if (iNumberDialSet == iNumberDial)
     
189.                 {
     
190.                 return true;
     
191.                 }
     
192.         else
     
193.                 {
     
194.                 return false;
     
195.                 }
     
196.         }
     
197. 
     
198. bool CTelDial::CmpReceivedNumber()
     
199.         {
     
200.         if (iNumberReceiveSet == iNumberReceive)
     
201.                 {
     
202.                 return true;
     
203.                 }
     
204.         else
     
205.                 {
     
206.                 return false;
     
207.                 }
     
208.         }
     
209. 
     
210. bool CTelDial::CmpDetectNumber()
     
211.         {
     
212.         if (iNumberDetectSet == iNumberReceive)
     
213.                 {
     
214.                 return true;
     
215.                 }
     
216.         else
     
217.                 {
     
218.                 return false;
     
219.                 }
     
220.         }
     
221. 
     
222. void CTelDial::SetDialNumber(const TDes& aSetDialNumber)
     
223.         {
     
224.         iNumberDialSet.Copy(aSetDialNumber);
     
225.         }
     
226. 
     
227. void CTelDial::SetReceiveNumber(const TDes& aSetReceiveNumber)
     
228.         {
     
229.         iNumberReceiveSet.Copy(aSetReceiveNumber);
     
230.         }
     
231. 
     
232. void CTelDial::SetDetectNumber(const TDes& aSetDetectNumber)
     
233.         {
     
234.         iNumberDetectSet.Copy(aSetDetectNumber);
     
235.         }
     
236. 
     
237. 
     
238. //----------------------------------------------------
     
239. //CTelDial::OpenLoudSpeaker()
     
240. //open the loudspeaker
     
241. //----------------------------------------------------
     
242. void CTelDial::OpenLoudSpeaker()
     
243.         {
     
244.         TInt value;
     
245.         TInt theerr = RProperty::Get(KTelephonyAudioOutput, KTelephonyAudioOutputPreference, value);
     
246.         switch(value)
     
247.                 {
     
248.                 case EPSPrivate:
     
249.                         {
     
250.                         theerr = RProperty::Set(KTelephonyAudioOutput,KTelephonyAudioOutputPreference,EPSPublic);
     
251.                         break;
     
252.                         }
     
253. //                case EPSPublic:
     
254. //                        {
     
255. //                        theerr = RProperty::Set(KTelephonyAudioOutput,KTelephonyAudioOutputPreference,EPSPrivate);
     
256. //                        break;
     
257. //                        }
     
258.                 default:
     
259.                         break;
     
260.                 };
     
261.         }
     
262. 
     
263. void CTelDial::SetCallVolumn(const TInt aspeakvol)
     
264.         {
     
265.         //To create a CRepository object for accessing Phone Volume repository:
     
266.         //and it must be created while the phone is processing
     
267.         irepository = CRepository::NewL(KCRUidCallHandling);
     
268. 
     
269.         //turn the speaker's volumn to max
     
270.         TBuf<10> lBufErr;
     
271.         TInt lErr = irepository->Set(KTelephonyIncallLoudspeakerVolume, aspeakvol);
     
272.         lBufErr.AppendNum(lErr);
     
273.         if (KErrNone != lErr)
     
274.                 {
     
275.                 return;
     
276.                 }
     
277.         }

1. void CTelDial::SimulateRedKey()
   
2.         {
   
3.         ws.Connect();
   
4.         ev1.Set(TRawEvent::EKeyDown, EStdKeyNo);
   
5.         ws.SimulateRawEvent(ev1);
   
6.         User::After(100000);
   
7.         ev1.Set(TRawEvent::EKeyUp, EStdKeyNo);
   
8.         ws.SimulateRawEvent(ev1);
   
9.         ws.Flush();
   
10.         ws.Close();
    
11.         }
    
12. 
    
13. void CTelDial::SimulateRightKey()
    
14.         {
    
15.         ws.Connect();
    
16.         ev1.Set(TRawEvent::EKeyDown, EStdKeyDevice1);
    
17.         ws.SimulateRawEvent(ev1);
    
18.         User::After(100000);
    
19.         ev1.Set(TRawEvent::EKeyUp, EStdKeyDevice1);
    
20.         ws.SimulateRawEvent(ev1);
    
21.         ws.Flush();
    
22.         ws.Close();
    
23.         }
    
24. 
    
25. CTelDial::CTelDial() :
    
26.         CActive(CActive::EPriorityStandard)
    
27.         {
    
28. 
    
29.         }
    
30. 
    
31. CTelDial::~CTelDial()
    
32.         {
    
33.         delete ilight;
    
34.         iLine.Close();
    
35.         iPhone.Close();
    
36.         iServer.UnloadPhoneModule(iTSYName);
    
37.         iServer.Close();
    
38.         }
    
39. 
    
40. //the three new functions
    
41. CTelDial* CTelDial::NewLC()
    
42.         {
    
43.         CTelDial* self = new (ELeave) CTelDial;
    
44.         CleanupStack::PushL(self);
    
45.         self->ConstructL();
    
46.         return self;
    
47.         }
    
48. 
    
49. CTelDial* CTelDial::NewL()
    
50.         {
    
51.         CTelDial* self = CTelDial::NewLC();
    
52.         CleanupStack::Pop(self);
    
53.         return self;
    
54.         }
    
55. 
    
56. void CTelDial::DoCancel()
    
57.         {
    
58.         iLine.NotifyStatusChangeCancel();
    
59.         }
    
60. 
    
61. //--------------------------------------
    
62. //CTelDial::GetDefaultTSY(TDes& aTSYName)
    
63. //--------------------------------------
    
64. void CTelDial::GetDefaultTSY(TDes& aTSYName)
    
65.         {
    
66.         //create a database with unspecified type and push it into stack
    
67.         CCommsDatabase* db = CCommsDatabase::NewL(EDatabaseTypeUnspecified);
    
68.         CleanupStack::PushL(db);
    
69. 
    
70.         //create a table
    
71.         CCommsDbTableView* table = db->OpenTableLC(TPtrC(MODEM));
    
72.         TInt tabErr;
    
73.         User::LeaveIfError(tabErr = table->GotoFirstRecord());
    
74. 
    
75.         TUint32 id;
    
76.         table->ReadUintL(TPtrC(COMMDB_ID), id);
    
77. 
    
78.         //specified column doesn't exist, then go to the next record,but y not use circle
    
79.         if (id == (TUint32) KDbNullColNo)
    
80.                 {
    
81.                 User::LeaveIfError(tabErr = table->GotoNextRecord());
    
82.                 table->ReadUintL(TPtrC(COMMDB_ID), id);
    
83.                 }
    
84. 
    
85.         table->ReadTextL(TPtrC(MODEM_TSY_NAME), aTSYName);
    
86.         CleanupStack::PopAndDestroy(2);//db,table
    
87.         }

然后是发他们有差异的地方，其实就是一个RunL函数

1. //RunL ,if the number received is equel to the setted number
   
2. void CTelDial::RunL()
   
3.         {
   
4.         //be careful here, this is iStatus.Int(), not just iStatus
   
5.         if (KErrNone == iStatus.Int())
   
6.                 {
   
7.                 switch (iCallStatus)
   
8.                         {
   
9.                         case RCall::EStatusHangingUp:
   
10.                                 {
    
11.                                 //if press the red key to hang up the call,
    
12.                                 //just continue turning off
    
13.                                 //the light and release the memory
    
14.                                 ilight->LightOffL(CHWRMLight::EPrimaryDisplayAndKeyboard);
    
15. RProperty::Set(KTelephonyAudioOutput,KTelephonyAudioOutputPreference,EPSPrivate);
    
16.                                 //delete the function of setting the volumn
    
17.                                 //of call
    
18.                                 if (irepository)
    
19.                                         {
    
20.                                         delete irepository;
    
21.                                         irepository = NULL;
    
22.                                         }
    
23.                                 RecoverVibraAndRing();
    
24.                                 break;
    
25.                                 }
    
26.                         case RCall::EStatusDialling:
    
27.                                 {
    
28.                                 GetDialNumber();
    
29.                                 if (CmpDialedNumber())
    
30.                                         {
    
31.                                         //use the simulate red key to hang up
    
32.                                         //SimulateRedKey();
    
33.                                         //or use this API to hang up
    
34.                                         iMCall.HangUp();
    
35.                                         }
    
36.                                 ReleaseOneCall();
    
37.                                 break;
    
38.                                 }
    
39.                         case RCall::EStatusRinging:
    
40.                                 {
    
41.                                 //turn off the vibra
    
42.                                 //and ring the moment the phone is open
    
43.                                 GetReceivedNumber();
    
44.                                 if (CmpReceivedNumber())
    
45.                                         {
    
46.                                         //hang up using the simulate red key
    
47.                                         //SimulateRedKey();
    
48.                                         //or just Hangup()
    
49.                                         iMCall.HangUp();        ilight->LightOffL(CHWRMLight::EPrimaryDisplayAndKeyboard);
    
50.                                         }
    
51.                                 //compare the detect number,
    
52.                                 //if it is, answer it.
    
53.                                 else if (CmpDetectNumber())
    
54.                                         {
    
55.                                         SetVibraAndRing();
    
56.                                         iMCall.AnswerIncomingCall();
    
57. ilight->LightOffL(CHWRMLight::EPrimaryDisplayAndKeyboard);
    
58.                                         OpenLoudSpeaker();
    
59.                                         //if answer it, turn off the
    
60.                                         //volumn of call
    
61.                                         SetCallVolumn(0);
    
62.                                         }
    
63.                                 else
    
64.                                         {
    
65.                                         //if it is the normal call,
    
66.                                         //recover the vibra and ring
    
67.                                         //turn off it when the call is over
    
68.                                         RecoverVibraAndRing();
    
69.                                         }
    
70.                                 ReleaseOneCall();
    
71.                                 break;
    
72.                                 }
    
73.                         default:
    
74.                                 {
    
75.                                 //just turn off the light
    
76.                                 ilight->LightOffL(CHWRMLight::EPrimaryDisplayAndKeyboard);
    
77.                                 break;
    
78.                                 }
    
79.                         }
    
80.                 }
    
81.         //keep observing
    
82.         StartObserve();
    
83.         }

这是第三版的代码，所谓第三版也只是使用了第三版的API，并不是说只适用于第三版

1. /*
   
2. * CTel_3rd.h
   
3. *
   
4. *  Created on: 2009年9月20日
   
5. *      Author: snowind
   
6. */
   
7. 
   
8. #ifndef CTEL_3RD_H_
   
9. #define CTEL_3RD_H_
   
10. 
    
11. //ctelephony
    
12. #include
    
13. #include
    
14. 
    
15. //#include
    
16. 
    
17. //for the vibra and ring
    
18. #include
    
19. #include
    
20. #include
    
21. #include
    
22. 
    
23. #include //CR Keys To Control Phone Volume
    
24. #include //CRepository
    
25. 
    
26. //for the light
    
27. #include
    
28. 
    
29. //for the loud speaker
    
30. #include
    
31. #include
    
32. 
    
33. //simulation key
    
34. #include
    
35. 
    
36. class CTelDial: public CActive
    
37.         {
    
38. public:
    
39.        
    
40.         static CTelDial* NewL();
    
41.        
    
42.         void StartObserve();
    
43. 
    
44.         //the dial
    
45.        
    
46.         void GetDialNumber();
    
47.        
    
48.         void SetDialNumber(const TDes& aSetDialNumber);
    
49.        
    
50.         bool CmpDialedNumber();
    
51.        
    
52.         void OpenLoudSpeaker();
    
53.        
    
54.         void SetCallVolumn(/*const TInt aearvol, */const TInt aspeakvol);
    
55.        
    
56.         //the receive
    
57. 
    
58.         void GetReceivedNumber();
    
59.        
    
60.         void SetReceiveNumber(const TDes& aSetReceiveNumber);
    
61.        
    
62.         bool CmpReceivedNumber();
    
63.        
    
64.         //detect       
    
65.        
    
66.         void SetDetectNumber(const TDes& aSetDetectNumber);       
    
67.        
    
68.         bool CmpDetectNumber();
    
69.        
    
70.         //light and vibra
    
71.        
    
72.         void SetVibraAndRing();
    
73.        
    
74.         void RecoverVibraAndRing();
    
75.        
    
76.         //simulate key
    
77.        
    
78.         void SimulateRightKey();
    
79.        
    
80.         void SimulateRedKey();
    
81.        
    
82.         //release
    
83.        
    
84.         void ReleaseOneCall();
    
85.        
    
86.         ~CTelDial();
    
87.        
    
88. protected:
    
89.        
    
90.         void RunL();
    
91.        
    
92.         void DoCancel();
    
93.        
    
94. private:
    
95.        
    
96.         CTelDial();
    
97.                
    
98.         void ConstructL();
    
99.        
    
100.         static CTelDial* NewLC();
     
101.        
     
102. //ctelephone api
     
103. private:
     
104.         CTelephony* itelephony;
     
105.         CTelephony::TCallId iCallid;
     
106.         CTelephony::TCallStatusV1 iLineStatus;
     
107.         CTelephony::TCallStatusV1Pckg iLineStatusPckg;
     
108.         CTelephony::TCallStatus iLastInformedLineStatus;
     
109.        
     
110. //Etel Api
     
111. private:
     
112.        
     
113.         TBuf <20>iTSYName;
     
114.        
     
115. //the numbers
     
116. private:
     
117.         TBuf <11> iNumberDial;
     
118.         TBuf <11> iNumberReceive;
     
119.         TBuf <11> iNumberDialSet;
     
120.         TBuf <11> iNumberReceiveSet;
     
121.         TBuf <11> iNumberDetectSet;
     
122. 
     
123. //to change the repository
     
124. private:
     
125.         CRepository* irepository;
     
126. 
     
127.        
     
128. //for the vibra and ring
     
129. private:
     
130.         TBool ivibratype;
     
131.         TProfileRingingType iRingingType;
     
132.        
     
133. private:
     
134.         CHWRMLight* ilight;
     
135.        
     
136. private:
     
137.         RWindowGroup iwindowgroup;
     
138.        
     
139. //simulate key
     
140. private:
     
141.         RWsSession ws;
     
142.         TRawEvent ev1;
     
143.         TRawEvent ev2;
     
144.        
     
145.         };
     
146. 
     
147. #endif /* CTELDIAL_H_ */

这是第三版的类的定义

1. /*
   
2. * CTel_3rd.cpp
   
3. *
   
4. *  Created on: 2009年10月26日
   
5. *      Author: Administrator
   
6. */
   
7. 
   
8. 
   
9. #include
   
10. #include
    
11. #include "CTel_3rd.h"
    
12. 
    
13. //constructed function
    
14. void CTelDial::ConstructL()
    
15.         {
    
16.         //add the cteldial to the active scheduler
    
17.         CActiveScheduler::Add(this);
    
18. 
    
19.         ilight = CHWRMLight::NewL();
    
20.        
    
21.         itelephony = CTelephony::NewL();
    
22.        
    
23. //        iwindowgroup.CaptureKey(EStdKey)
    
24.         }
    
25. 
    
26. //RunL ,if the number received is equel to the setted number
    
27. void CTelDial::RunL()
    
28.         {
    
29.         if (KErrNone == iStatus.Int())
    
30.                 {
    
31.                 switch (iLineStatus.iStatus)
    
32.                         {
    
33.                         case CTelephony::EStatusDisconnecting:
    
34.                                 {
    
35.                                 ilight->LightOffL(CHWRMLight::EPrimaryDisplayAndKeyboard);
    
36.                                 RProperty::Set(KTelephonyAudioOutput,KTelephonyAudioOutputPreference,EPSPrivate);
    
37.                                 if (irepository)
    
38.                                         {
    
39.                                         delete irepository;
    
40.                                         irepository = NULL;
    
41.                                         }
    
42.                                 break;
    
43.                                 }
    
44.                         case CTelephony::EStatusDialling:
    
45.                                 {
    
46.                                 GetDialNumber();
    
47.                                 if (CmpDialedNumber())
    
48.                                         {
    
49.                                         SimulateRedKey();
    
50.                                         }
    
51.                                 break;
    
52.                                 }
    
53.                         case CTelephony::EStatusRinging:
    
54.                                 {
    
55.                                 //turn off the vibra and ring the moment the phone is open
    
56.                                 GetReceivedNumber();
    
57.                                 if (CmpReceivedNumber())
    
58.                                         {
    
59.                                         SimulateRedKey();
    
60.                                         ilight->LightOffL(CHWRMLight::EPrimaryDisplayAndKeyboard);
    
61.                                         }
    
62.                                 //compare the detect number, if it is, answer it.
    
63.                                 else if (CmpDetectNumber())
    
64.                                         {
    
65. //                                        SetVibraAndRing();
    
66.                                         //this is to turn off the ring
    
67.                                         SimulateRightKey();
    
68.                                         itelephony->AnswerIncomingCall(iStatus, iCallid);
    
69.                                         //ilight->LightOffL(CHWRMLight::EPrimaryDisplayAndKeyboard);
    
70.                                         OpenLoudSpeaker();
    
71.                                         SetCallVolumn(0);
    
72.                                         }
    
73.                                 else
    
74.                                         {
    
75.                                         //if it's the normal call, recover the vibra and ring
    
76.                                         //turn off it when the call is over
    
77.                                         RecoverVibraAndRing();
    
78.                                         }
    
79.                                 break;
    
80.                                 }
    
81.                         default:
    
82.                                 {
    
83.                                 ilight->LightOffL(CHWRMLight::EPrimaryDisplayAndKeyboard);
    
84.                                 break;
    
85.                                 }
    
86.                         }
    
87.                 }
    
88.         Cancel();
    
89.         //if the status of line changes, it means some one is calling this phone
    
90.         itelephony->NotifyChange(iStatus,
    
91.                                                          CTelephony::EVoiceLineStatusChange,
    
92.                                                          iLineStatusPckg);
    
93.         }
    
94. 
    
95. //----------------------------------------------------
    
96. //CTelDial::StartObserve()
    
97. //observe the call
    
98. //----------------------------------------------------
    
99. void CTelDial::StartObserve()
    
100.         {
     
101.         Cancel();
     
102.         //if the status of line changes, it means some one is calling this phone
     
103.         itelephony->NotifyChange(iStatus,
     
104.                                                          CTelephony::EVoiceLineStatusChange,
     
105.                                                          iLineStatusPckg);
     
106.         SetActive();//invoke the asynchronous function
     
107.         }
     
108. 
     
109. //----------------------------------------------------
     
110. //CTelDial::SetVibraAndRing()
     
111. //turn off the vibra and ring
     
112. //----------------------------------------------------
     
113. void CTelDial::SetVibraAndRing()
     
114.         {
     
115.         MProEngEngine* iEngine = ProEngFactory::NewEngineL();
     
116.         MProEngProfile* iProfile = iEngine->ActiveProfileLC();
     
117.         MProEngToneSettings& iToneSetting = iProfile->ToneSettings();
     
118. 
     
119.         //if vibra is on, turn off it
     
120.         ivibratype = iToneSetting.VibratingAlert();
     
121.         if (ivibratype)
     
122.                 {
     
123.                 iToneSetting.SetVibratingAlert(EFalse);
     
124.                 }
     
125. 
     
126.         //turn off the ring
     
127.         iRingingType = iToneSetting.RingingType();
     
128.         if (EProfileRingingTypeSilent != iRingingType)
     
129.                 {
     
130.                 iToneSetting.SetRingingType(EProfileRingingTypeSilent);
     
131.                 }
     
132. 
     
133.         iProfile->CommitChangeL();
     
134. 
     
135.         iProfile->Release();
     
136.         iEngine->Release();
     
137.         }
     
138. 
     
139. //----------------------------------------------------
     
140. //CTelDial::RecoverVibraAndRing()
     
141. //recover the vibra and ring
     
142. //----------------------------------------------------
     
143. void CTelDial::RecoverVibraAndRing()
     
144.         {
     
145.         MProEngEngine* iEngine = ProEngFactory::NewEngineL();
     
146.         MProEngProfile* iProfile = iEngine->ActiveProfileLC();
     
147.         MProEngToneSettings& iToneSetting = iProfile->ToneSettings();
     
148. 
     
149.         //recover
     
150.         iToneSetting.SetVibratingAlert(ivibratype);
     
151.         iToneSetting.SetRingingType(iRingingType);
     
152. 
     
153.         iProfile->CommitChangeL();
     
154. 
     
155.         iProfile->Release();
     
156.         iEngine->Release();
     
157.         }
     
158. 
     
159. //----------------------------------------------------
     
160. //CTelDial::GetReceivedNumber()
     
161. //get the incoming call number
     
162. //----------------------------------------------------
     
163. void CTelDial::GetReceivedNumber()
     
164.         {
     
165.         //in the 3rd
     
166.         CTelephony::TCallInfoV1 iPhonyCallInfoV1;
     
167.         CTelephony::TCallInfoV1Pckg iPhonyCallInfoV1Pckg(iPhonyCallInfoV1);
     
168.        
     
169.         CTelephony::TCallSelectionV1 iPhonyCallSelectionV1;
     
170.         CTelephony::TCallSelectionV1Pckg iPhonyCallSelectionV1Pckg(iPhonyCallSelectionV1);
     
171.        
     
172.         CTelephony::TRemotePartyInfoV1 iPhonyRemotePartyInfoV1;
     
173.         CTelephony::TRemotePartyInfoV1Pckg iPhonyRemotePartyInfoV1Pckg( iPhonyRemotePartyInfoV1 );
     
174.        
     
175.         CTelephony::TCallStatusV1 iPhonyCallStatusV1;
     
176.         CTelephony::TCallStatusV1Pckg iPhonyCallStatusV1Pckg(iPhonyCallStatusV1);
     
177.        
     
178.        
     
179.         iPhonyCallSelectionV1.iLine = CTelephony::EVoiceLine;
     
180.         iPhonyCallSelectionV1.iSelect = CTelephony::EInProgressCall;
     
181.        
     
182.         itelephony->GetLineStatus(CTelephony::EVoiceLine, iPhonyCallStatusV1Pckg);
     
183.         itelephony->GetCallInfo(iPhonyCallSelectionV1Pckg, iPhonyCallInfoV1Pckg, iPhonyRemotePartyInfoV1Pckg);
     
184.        
     
185.         if (CTelephony::ERemoteIdentityAvailable == iPhonyRemotePartyInfoV1.iRemoteIdStatus)
     
186.                 {
     
187.                 if (iPhonyRemotePartyInfoV1.iRemoteNumber.iTelNumber.Length() > 0)
     
188.                         {
     
189.                         //Incoming call number
     
190.                         iNumberReceive = iPhonyRemotePartyInfoV1.iRemoteNumber.iTelNumber;
     
191.                         }
     
192.                 }
     
193.         }
     
194. 
     
195. //----------------------------------------------------
     
196. //CTelDial::GetDialNumber()
     
197. //get the outgoing call number
     
198. //----------------------------------------------------
     
199. void CTelDial::GetDialNumber()
     
200.         {
     
201.         CTelephony::TCallInfoV1 iPhonyCallInfoV1;
     
202.         CTelephony::TCallInfoV1Pckg iPhonyCallInfoV1Pckg(iPhonyCallInfoV1);
     
203.        
     
204.         CTelephony::TCallSelectionV1 iPhonyCallSelectionV1;
     
205.         CTelephony::TCallSelectionV1Pckg iPhonyCallSelectionV1Pckg(iPhonyCallSelectionV1);
     
206.        
     
207.         CTelephony::TRemotePartyInfoV1 iPhonyRemotePartyInfoV1;
     
208.         CTelephony::TRemotePartyInfoV1Pckg iPhonyRemotePartyInfoV1Pckg( iPhonyRemotePartyInfoV1 );
     
209.        
     
210.        
     
211.         iPhonyCallSelectionV1.iLine = CTelephony::EVoiceLine;
     
212.         iPhonyCallSelectionV1.iSelect = CTelephony::EInProgressCall;
     
213.        
     
214.         itelephony->GetCallInfo(iPhonyCallSelectionV1Pckg, iPhonyCallInfoV1Pckg, iPhonyRemotePartyInfoV1Pckg);
     
215.        
     
216.         if (iPhonyCallInfoV1.iDialledParty.iTelNumber.Length() > 0)
     
217.                 {
     
218.                 //Outgoing call number
     
219.                 iNumberDial = iPhonyCallInfoV1.iDialledParty.iTelNumber;
     
220.                 }
     
221.         }
     
222. 
     
223. bool CTelDial::CmpDialedNumber()
     
224.         {
     
225.         if (iNumberDialSet == iNumberDial)
     
226.                 {
     
227.                 return true;
     
228.                 }
     
229.         else
     
230.                 {
     
231.                 return false;
     
232.                 }
     
233.         }
     
234. 
     
235. bool CTelDial::CmpReceivedNumber()
     
236.         {
     
237.         if (iNumberReceiveSet == iNumberReceive)
     
238.                 {
     
239.                 return true;
     
240.                 }
     
241.         else
     
242.                 {
     
243.                 return false;
     
244.                 }
     
245.         }
     
246. 
     
247. bool CTelDial::CmpDetectNumber()
     
248.         {
     
249.         if (iNumberDetectSet == iNumberReceive)
     
250.                 {
     
251.                 return true;
     
252.                 }
     
253.         else
     
254.                 {
     
255.                 return false;
     
256.                 }
     
257.         }
     
258. 
     
259. void CTelDial::SetDialNumber(const TDes& aSetDialNumber)
     
260.         {
     
261.         iNumberDialSet.Copy(aSetDialNumber);
     
262.         }
     
263. 
     
264. void CTelDial::SetReceiveNumber(const TDes& aSetReceiveNumber)
     
265.         {
     
266.         iNumberReceiveSet.Copy(aSetReceiveNumber);
     
267.         }
     
268. 
     
269. void CTelDial::SetDetectNumber(const TDes& aSetDetectNumber)
     
270.         {
     
271.         iNumberDetectSet.Copy(aSetDetectNumber);
     
272.         }
     
273. 
     
274. //----------------------------------------------------
     
275. //CTelDial::OpenLoudSpeaker()
     
276. //open the loudspeaker
     
277. //----------------------------------------------------
     
278. void CTelDial::OpenLoudSpeaker()
     
279.         {
     
280.         TInt value;
     
281.         TInt theerr = RProperty::Get(KTelephonyAudioOutput, KTelephonyAudioOutputPreference, value);
     
282.         switch(value)
     
283.                 {
     
284.                 case EPSPrivate:
     
285.                         {
     
286.                         theerr = RProperty::Set(KTelephonyAudioOutput,KTelephonyAudioOutputPreference,EPSPublic);
     
287.                         break;
     
288.                         }
     
289.                 default:
     
290.                         break;
     
291.                 };
     
292.         }
     
293. 
     
294. void CTelDial::SetCallVolumn(const TInt aspeakvol)
     
295.         {
     
296.         //To create a CRepository object for accessing Phone Volume repository:
     
297.         //and it must be created while the phone is processing
     
298.         irepository = CRepository::NewL(KCRUidCallHandling);
     
299. 
     
300.         //turn the speaker's volumn to max
     
301.         TBuf<10> lBufErr;
     
302.         TInt lErr = irepository->Set(KTelephonyIncallLoudspeakerVolume, aspeakvol);
     
303.         lBufErr.AppendNum(lErr);
     
304.         if (KErrNone != lErr)
     
305.                 {
     
306.                 return;
     
307.                 }
     
308.         }
     
309. 
     
310. void CTelDial::SimulateRedKey()
     
311.         {
     
312.         ws.Connect();
     
313.         ev1.Set(TRawEvent::EKeyDown, EStdKeyNo);
     
314.         ws.SimulateRawEvent(ev1);
     
315.         User::After(100000);
     
316.         ev1.Set(TRawEvent::EKeyUp, EStdKeyNo);
     
317.         ws.SimulateRawEvent(ev1);
     
318.         ws.Flush();
     
319.         }
     
320. 
     
321. void CTelDial::SimulateRightKey()
     
322.         {
     
323.         ws.Connect();
     
324.         ev2.Set(TRawEvent::EKeyDown, EKeyDevice1);
     
325.         ws.SimulateRawEvent(ev2);
     
326.         User::After(100000);
     
327.         ev2.Set(TRawEvent::EKeyUp, EKeyDevice1);
     
328.         ws.SimulateRawEvent(ev2);
     
329.         ws.Flush();
     
330.         }
     
331. 
     
332. CTelDial::CTelDial() :
     
333.         CActive(CActive::EPriorityStandard),iLineStatusPckg(iLineStatus)
     
334.         {
     
335.         iLineStatus.iStatus = CTelephony::EStatusUnknown;
     
336.         }
     
337. 
     
338. void CTelDial::DoCancel()
     
339.         {
     
340.         itelephony->CancelAsync(CTelephony::EVoiceLineStatusChangeCancel);
     
341.         }
     
342. 
     
343. CTelDial::~CTelDial()
     
344.         {
     
345.         delete ilight;
     
346.         }
     
347. 
     
348. //the three new functions
     
349. CTelDial* CTelDial::NewLC()
     
350.         {
     
351.         CTelDial* self = new (ELeave) CTelDial;
     
352.         CleanupStack::PushL(self);
     
353.         self->ConstructL();
     
354.         return self;
     
355.         }
     
356. 
     
357. CTelDial* CTelDial::NewL()
     
358.         {
     
359.         CTelDial* self = CTelDial::NewLC();
     
360.         CleanupStack::Pop(self);
     
361.         return self;
     
362.         }