Merge remote-tracking branch 'origin/master' into generic-java
[iotivity.git] / resource / csdk / connectivity / util / src / cautilinterface.c
1 /* ****************************************************************
2  *
3  * Copyright 2016 Samsung Electronics All Rights Reserved.
4  *
5  *
6  *
7  * Licensed under the Apache License, Version 2.0 (the "License");
8  * you may not use this file except in compliance with the License.
9  * You may obtain a copy of the License at
10  *
11  *      http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing, software
14  * distributed under the License is distributed on an "AS IS" BASIS,
15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16  * See the License for the specific language governing permissions and
17  * limitations under the License.
18  *
19  ******************************************************************/
20
21 #include "camanagerleinterface.h"
22 #include "cabtpairinginterface.h"
23 #include "cautilinterface.h"
24 #include "cainterfacecontroller.h"
25 #include "cacommon.h"
26 #include "logger.h"
27
28 #define TAG "OIC_CA_COMMON_UTILS"
29
30 CAResult_t CARegisterNetworkMonitorHandler(CAAdapterStateChangedCB adapterStateCB,
31                                            CAConnectionStateChangedCB connStateCB)
32 {
33     OIC_LOG(DEBUG, TAG, "CARegisterNetworkMonitorHandler");
34
35     return CASetNetworkMonitorCallbacks(adapterStateCB, connStateCB);
36 }
37
38 CAResult_t CAUnregisterNetworkMonitorHandler(CAAdapterStateChangedCB adapterStateCB,
39                                              CAConnectionStateChangedCB connStateCB)
40 {
41     OIC_LOG(DEBUG, TAG, "CAUnregisterNetworkMonitorHandler");
42
43     return CAUnsetNetworkMonitorCallbacks(adapterStateCB, connStateCB);
44 }
45
46 CAResult_t CASetAutoConnectionDeviceInfo(const char *address)
47 {
48     OIC_LOG(DEBUG, TAG, "CASetAutoConnectionDeviceInfo");
49
50 #if defined(__ANDROID__) && defined(LE_ADAPTER)
51     return CASetLEClientAutoConnectionDeviceInfo(address);
52 #else
53     (void)address;
54     return CA_NOT_SUPPORTED;
55 #endif
56 }
57
58 CAResult_t CAUnsetAutoConnectionDeviceInfo(const char *address)
59 {
60     OIC_LOG(DEBUG, TAG, "CAUnsetAutoConnectionDeviceInfo");
61
62 #if defined(__ANDROID__) && defined(LE_ADAPTER)
63     return CAUnsetLEClientAutoConnectionDeviceInfo(address);
64 #else
65     (void)address;
66     return CA_NOT_SUPPORTED;
67 #endif
68 }
69
70 CAResult_t CASetPortNumberToAssign(CATransportAdapter_t adapter,
71                                    CATransportFlags_t flag, uint16_t port)
72 {
73     uint16_t *targetPort = 0;
74
75     if (CA_ADAPTER_IP & adapter)
76     {
77         if (CA_SECURE & flag)
78         {
79             if (CA_IPV6 & flag)
80             {
81                 targetPort = &caglobals.ports.udp.u6s;
82             }
83             else if (CA_IPV4 & flag)
84             {
85                 targetPort = &caglobals.ports.udp.u4s;
86             }
87         }
88         else
89         {
90             if (CA_IPV6 & flag)
91             {
92                 targetPort = &caglobals.ports.udp.u6;
93             }
94             else if (CA_IPV4 & flag)
95             {
96                 targetPort = &caglobals.ports.udp.u4;
97             }
98         }
99     }
100 #ifdef TCP_ADAPTER
101     if (CA_ADAPTER_TCP & adapter)
102     {
103         if (CA_IPV6 & flag)
104         {
105             targetPort = &caglobals.ports.tcp.u6;
106         }
107         else if (CA_IPV4 & flag)
108         {
109             targetPort = &caglobals.ports.tcp.u4;
110         }
111     }
112 #endif
113
114     if (targetPort)
115     {
116         *targetPort = port;
117         return CA_STATUS_OK;
118     }
119
120     return CA_NOT_SUPPORTED;
121 }
122
123 uint16_t CAGetAssignedPortNumber(CATransportAdapter_t adapter, CATransportFlags_t flag)
124 {
125     OIC_LOG(DEBUG, TAG, "CAGetAssignedPortNumber");
126
127     if (CA_ADAPTER_IP & adapter)
128     {
129         if (CA_SECURE & flag)
130         {
131             if (CA_IPV6 & flag)
132             {
133                 return caglobals.ip.u6s.port;
134             }
135             else if (CA_IPV4 & flag)
136             {
137                 return caglobals.ip.u4s.port;
138             }
139         }
140         else
141         {
142             if (CA_IPV6 & flag)
143             {
144                 return caglobals.ip.u6.port;
145             }
146             else if (CA_IPV4 & flag)
147             {
148                 return caglobals.ip.u4.port;
149             }
150         }
151     }
152 #ifdef TCP_ADAPTER
153     if (CA_ADAPTER_TCP & adapter)
154     {
155         if (CA_IPV6 & flag)
156         {
157             return caglobals.tcp.ipv6.port;
158         }
159         else if (CA_IPV4 & flag)
160         {
161             return caglobals.tcp.ipv4.port;
162         }
163     }
164 #endif
165     return 0;
166 }
167
168 #ifdef __JAVA__
169 #ifdef __ANDROID__
170 /**
171  * initialize client connection manager
172  * @param[in]   env                   JNI interface pointer.
173  * @param[in]   jvm                   invocation inferface for JAVA virtual machine.
174  * @param[in]   context               application context.
175  */
176 CAResult_t CAUtilClientInitialize(JNIEnv *env, JavaVM *jvm, jobject context)
177 {
178     OIC_LOG(DEBUG, TAG, "CAUtilClientInitialize");
179
180     CAResult_t res = CA_STATUS_OK;
181 #ifdef LE_ADAPTER
182     if (CA_STATUS_OK != CAManagerLEClientInitialize(env, jvm, context))
183     {
184         OIC_LOG(ERROR, TAG, "CAManagerLEClientInitialize has failed");
185         res = CA_STATUS_FAILED;
186     }
187 #endif
188
189 #ifdef EDR_ADAPTER
190     if (CA_STATUS_OK != CABTPairingInitialize(env, jvm, context))
191     {
192         OIC_LOG(ERROR, TAG, "CABTPairingInitialize has failed");
193         res = CA_STATUS_FAILED;
194     }
195 #endif
196
197 #if !defined(LE_ADAPTER) && !defined(EDR_ADAPTER)
198     (void)env;
199     (void)jvm;
200     (void)context;
201 #endif
202     return res;
203 }
204 #else
205 /**
206  * initialize client connection manager
207  * @param[in]   env                   JNI interface pointer.
208  * @param[in]   jvm                   invocation inferface for JAVA virtual machine.
209  */
210 CAResult_t CAUtilClientInitialize(JNIEnv *env, JavaVM *jvm)
211 {
212     OIC_LOG(DEBUG, TAG, "CAUtilClientInitialize");
213
214     CAResult_t res = CA_STATUS_OK;
215 #ifdef LE_ADAPTER
216     if (CA_STATUS_OK != CAManagerLEClientInitialize(env, jvm))
217     {
218         OIC_LOG(ERROR, TAG, "CAManagerLEClientInitialize has failed");
219         res = CA_STATUS_FAILED;
220     }
221 #endif
222
223 #ifdef EDR_ADAPTER
224     if (CA_STATUS_OK != CABTPairingInitialize(env, jvm))
225     {
226         OIC_LOG(ERROR, TAG, "CABTPairingInitialize has failed");
227         res = CA_STATUS_FAILED;
228     }
229 #endif
230     return res;
231 }
232
233 #endif //__ANDROID__
234
235 /**
236  * terminate client connection manager
237  * @param[in]   env                   JNI interface pointer.
238  */
239 CAResult_t CAUtilClientTerminate(JNIEnv *env)
240 {
241     OIC_LOG(DEBUG, TAG, "CAUtilClientTerminate");
242 #ifdef LE_ADAPTER
243     return CAManagerLEClientTerminate(env);
244 #else
245     OIC_LOG(DEBUG, TAG, "it is not supported");
246     (void)env;
247     return CA_NOT_SUPPORTED;
248 #endif
249 }
250
251 // BT pairing
252 CAResult_t CAUtilStartScan(JNIEnv *env)
253 {
254 #ifdef EDR_ADAPTER
255     return CABTPairingStartScan(env);
256 #else
257     OIC_LOG(DEBUG, TAG, "it is not supported");
258     (void)env;
259     return CA_NOT_SUPPORTED;
260 #endif
261 }
262
263 CAResult_t CAUtilStopScan(JNIEnv *env)
264 {
265 #ifdef EDR_ADAPTER
266     return CABTPairingStopScan(env);
267 #else
268     OIC_LOG(DEBUG, TAG, "it is not supported");
269     (void)env;
270     return CA_NOT_SUPPORTED;
271 #endif
272 }
273
274 CAResult_t CAUtilCreateBond(JNIEnv *env, jobject device)
275 {
276 #ifdef EDR_ADAPTER
277     return CABTPairingCreateBond(env, device);
278 #else
279     OIC_LOG(DEBUG, TAG, "it is not supported");
280     (void)env;
281     (void)device;
282     return CA_NOT_SUPPORTED;
283 #endif
284 }
285
286 void CAUtilSetFoundDeviceListener(jobject listener)
287 {
288 #ifdef EDR_ADAPTER
289     CABTPairingSetFoundDeviceListener(listener);
290 #else
291     (void)listener;
292 #endif
293 }
294
295 CAResult_t CAUtilSetLEScanInterval(jint intervalTime, jint workingCount)
296 {
297     OIC_LOG(DEBUG, TAG, "CAUtilSetLEScanInterval");
298 #ifdef LE_ADAPTER
299     CAManagerLESetScanInterval(intervalTime, workingCount);
300     return CA_STATUS_OK;
301 #else
302     (void)intervalTime;
303     (void)workingCount;
304     OIC_LOG(DEBUG, TAG, "it is not supported");
305     return CA_NOT_SUPPORTED;
306 #endif
307 }
308
309 CAResult_t CAUtilStopLEScan()
310 {
311     OIC_LOG(DEBUG, TAG, "CAUtilStopLEScan");
312 #ifdef LE_ADAPTER
313     CAManagerLEStopScan();
314     return CA_STATUS_OK;
315 #else
316     OIC_LOG(DEBUG, TAG, "it is not supported");
317     return CA_NOT_SUPPORTED;
318 #endif
319 }
320 #endif