Home | History | Annotate | Download | only in jni 
      1 /*
      2  * Copyright (C) 2010 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 #include <semaphore.h>
     18 #include <errno.h>
     19 
     20 #include "com_android_nfc.h"
     21 
     22 namespace android {
     23 
     24 /*
     25  * Callbacks
     26  */
     27 
     28 static void nfc_jni_receive_callback(void* pContext, uint8_t ssap, NFCSTATUS status)
     29 {
     30    struct nfc_jni_callback_data * pCallbackData = (struct nfc_jni_callback_data *) pContext;
     31    LOG_CALLBACK("nfc_jni_receiveFrom_callback", status);
     32 
     33    if(status == NFCSTATUS_SUCCESS)
     34    {
     35       pCallbackData->pContext = (void*)ssap;
     36       TRACE("RECEIVE UI_FRAME FROM SAP %d OK \n", ssap);
     37    }
     38 
     39    /* Report the callback status and wake up the caller */
     40    pCallbackData->status = status;
     41    sem_post(&pCallbackData->sem);
     42 }
     43 
     44 static void nfc_jni_send_callback(void *pContext, NFCSTATUS status)
     45 {
     46    struct nfc_jni_callback_data * pCallbackData = (struct nfc_jni_callback_data *) pContext;
     47    LOG_CALLBACK("nfc_jni_sendTo_callback", status);
     48 
     49    /* Report the callback status and wake up the caller */
     50    pCallbackData->status = status;
     51    sem_post(&pCallbackData->sem);
     52 }
     53 
     54 /*
     55 * Methods
     56 */
     57 static jboolean com_android_nfc_NativeLlcpConnectionlessSocket_doSendTo(JNIEnv *e, jobject o, jint nsap, jbyteArray data)
     58 {
     59    NFCSTATUS ret;
     60    struct timespec ts;
     61    phLibNfc_Handle hRemoteDevice;
     62    phLibNfc_Handle hLlcpSocket;
     63    phNfc_sData_t sSendBuffer = {NULL, 0};
     64    struct nfc_jni_callback_data cb_data;
     65    jboolean result = JNI_FALSE;
     66 
     67    /* Retrieve handles */
     68    hRemoteDevice = nfc_jni_get_p2p_device_handle(e,o);
     69    hLlcpSocket = nfc_jni_get_nfc_socket_handle(e,o);
     70 
     71    /* Create the local semaphore */
     72    if (!nfc_cb_data_init(&cb_data, NULL))
     73    {
     74       goto clean_and_return;
     75    }
     76 
     77    sSendBuffer.buffer = (uint8_t*)e->GetByteArrayElements(data, NULL);
     78    sSendBuffer.length = (uint32_t)e->GetArrayLength(data);
     79 
     80    TRACE("phLibNfc_Llcp_SendTo()");
     81    REENTRANCE_LOCK();
     82    ret = phLibNfc_Llcp_SendTo(hRemoteDevice,
     83                               hLlcpSocket,
     84                               nsap,
     85                               &sSendBuffer,
     86                               nfc_jni_send_callback,
     87                               (void*)&cb_data);
     88    REENTRANCE_UNLOCK();
     89    if(ret != NFCSTATUS_PENDING)
     90    {
     91       LOGE("phLibNfc_Llcp_SendTo() returned 0x%04x[%s]", ret, nfc_jni_get_status_name(ret));
     92       goto clean_and_return;
     93    }
     94    TRACE("phLibNfc_Llcp_SendTo() returned 0x%04x[%s]", ret, nfc_jni_get_status_name(ret));
     95 
     96    /* Wait for callback response */
     97    if(sem_wait(&cb_data.sem))
     98    {
     99       LOGE("Failed to wait for semaphore (errno=0x%08x)", errno);
    100       goto clean_and_return;
    101    }
    102 
    103    if(cb_data.status != NFCSTATUS_SUCCESS)
    104    {
    105       goto clean_and_return;
    106    }
    107 
    108    result = JNI_TRUE;
    109 
    110 clean_and_return:
    111    if (sSendBuffer.buffer != NULL)
    112    {
    113       e->ReleaseByteArrayElements(data, (jbyte*)sSendBuffer.buffer, JNI_ABORT);
    114    }
    115    nfc_cb_data_deinit(&cb_data);
    116    return result;
    117 }
    118 
    119 static jobject com_android_nfc_NativeLlcpConnectionlessSocket_doReceiveFrom(JNIEnv *e, jobject o, jint linkMiu)
    120 {
    121    NFCSTATUS ret;
    122    struct timespec ts;
    123    uint8_t ssap;
    124    jobject llcpPacket = NULL;
    125    phLibNfc_Handle hRemoteDevice;
    126    phLibNfc_Handle hLlcpSocket;
    127    phNfc_sData_t sReceiveBuffer;
    128    jclass clsLlcpPacket;
    129    jfieldID f;
    130    jbyteArray receivedData = NULL;
    131    struct nfc_jni_callback_data cb_data;
    132 
    133    /* Create the local semaphore */
    134    if (!nfc_cb_data_init(&cb_data, NULL))
    135    {
    136       goto clean_and_return;
    137    }
    138 
    139    /* Create new LlcpPacket object */
    140    if(nfc_jni_cache_object(e,"android/nfc/LlcpPacket",&(llcpPacket)) == -1)
    141    {
    142       LOGE("Find LlcpPacket class error");
    143       goto clean_and_return;
    144    }
    145 
    146    /* Get NativeConnectionless class object */
    147    clsLlcpPacket = e->GetObjectClass(llcpPacket);
    148    if(e->ExceptionCheck())
    149    {
    150       LOGE("Get Object class error");
    151       goto clean_and_return;
    152    }
    153 
    154    /* Retrieve handles */
    155    hRemoteDevice = nfc_jni_get_p2p_device_handle(e,o);
    156    hLlcpSocket = nfc_jni_get_nfc_socket_handle(e,o);
    157    TRACE("phLibNfc_Llcp_RecvFrom(), Socket Handle = 0x%02x, Link LIU = %d", hLlcpSocket, linkMiu);
    158 
    159    sReceiveBuffer.buffer = (uint8_t*)malloc(linkMiu);
    160    sReceiveBuffer.length = linkMiu;
    161 
    162    REENTRANCE_LOCK();
    163    ret = phLibNfc_Llcp_RecvFrom(hRemoteDevice,
    164                                 hLlcpSocket,
    165                                 &sReceiveBuffer,
    166                                 nfc_jni_receive_callback,
    167                                 &cb_data);
    168    REENTRANCE_UNLOCK();
    169    if(ret != NFCSTATUS_PENDING)
    170    {
    171       LOGE("phLibNfc_Llcp_RecvFrom() returned 0x%04x[%s]", ret, nfc_jni_get_status_name(ret));
    172       goto clean_and_return;
    173    }
    174    TRACE("phLibNfc_Llcp_RecvFrom() returned 0x%04x[%s]", ret, nfc_jni_get_status_name(ret));
    175 
    176    /* Wait for callback response */
    177    if(sem_wait(&cb_data.sem))
    178    {
    179       LOGE("Failed to wait for semaphore (errno=0x%08x)", errno);
    180       goto clean_and_return;
    181    }
    182 
    183    if(cb_data.status != NFCSTATUS_SUCCESS)
    184    {
    185        goto clean_and_return;
    186    }
    187 
    188    ssap = (uint32_t)cb_data.pContext;
    189    TRACE("Data Received From SSAP = %d\n, length = %d", ssap, sReceiveBuffer.length);
    190 
    191    /* Set Llcp Packet remote SAP */
    192    f = e->GetFieldID(clsLlcpPacket, "mRemoteSap", "I");
    193    e->SetIntField(llcpPacket, f,(jbyte)ssap);
    194 
    195    /* Set Llcp Packet Buffer */
    196    LOGD("Set LlcpPacket Data Buffer\n");
    197    f = e->GetFieldID(clsLlcpPacket, "mDataBuffer", "[B");
    198    receivedData = e->NewByteArray(sReceiveBuffer.length);
    199    e->SetByteArrayRegion(receivedData, 0, sReceiveBuffer.length,(jbyte *)sReceiveBuffer.buffer);
    200    e->SetObjectField(llcpPacket, f, receivedData);
    201 
    202 clean_and_return:
    203    if (receivedData != NULL)
    204    {
    205       e->ReleaseByteArrayElements(receivedData, (jbyte*)sReceiveBuffer.buffer, 0);
    206    }
    207    nfc_cb_data_deinit(&cb_data);
    208    return llcpPacket;
    209 }
    210 
    211 static jboolean com_android_nfc_NativeLlcpConnectionlessSocket_doClose(JNIEnv *e, jobject o)
    212 {
    213    NFCSTATUS ret;
    214    phLibNfc_Handle hLlcpSocket;
    215    TRACE("Close Connectionless socket");
    216 
    217    /* Retrieve socket handle */
    218    hLlcpSocket = nfc_jni_get_nfc_socket_handle(e,o);
    219 
    220    TRACE("phLibNfc_Llcp_Close()");
    221    REENTRANCE_LOCK();
    222    ret = phLibNfc_Llcp_Close(hLlcpSocket);
    223    REENTRANCE_UNLOCK();
    224    if(ret == NFCSTATUS_SUCCESS)
    225    {
    226       TRACE("phLibNfc_Llcp_Close() returned 0x%04x[%s]", ret, nfc_jni_get_status_name(ret));
    227       return TRUE;
    228    }
    229    else
    230    {
    231       LOGE("phLibNfc_Llcp_Close() returned 0x%04x[%s]", ret, nfc_jni_get_status_name(ret));
    232       return FALSE;
    233    }
    234 }
    235 
    236 
    237 /*
    238  * JNI registration.
    239  */
    240 static JNINativeMethod gMethods[] =
    241 {
    242    {"doSendTo", "(I[B)Z", (void *)com_android_nfc_NativeLlcpConnectionlessSocket_doSendTo},
    243 
    244    {"doReceiveFrom", "(I)Landroid/nfc/LlcpPacket;", (void *)com_android_nfc_NativeLlcpConnectionlessSocket_doReceiveFrom},
    245 
    246    {"doClose", "()Z", (void *)com_android_nfc_NativeLlcpConnectionlessSocket_doClose},
    247 };
    248 
    249 
    250 int register_com_android_nfc_NativeLlcpConnectionlessSocket(JNIEnv *e)
    251 {
    252    return jniRegisterNativeMethods(e,
    253       "com/android/nfc/nxp/NativeLlcpConnectionlessSocket",
    254       gMethods, NELEM(gMethods));
    255 }
    256 
    257 } // android namespace
    258