Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge a851d8d0 from gingerbread

Browse Source 
Change-Id: Iea0e3fa1662d6326ab337821fe52a65a9dfd989a
This commit is contained in:
Jean-Baptiste Queru
2010-10-15 17:02:57 -07:00
parent 6bc34da8ac a851d8d0cf
commit 36e7790b6b
19 changed files with 344 additions and 3012 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
cmds/servicemanager/service_manager.c
View File

@@ -36,6 +36,7 @@ static struct {
{ AID_MEDIA, "media.audio_policy" },
{ AID_DRMIO, "drm.drmIOService" },
{ AID_DRM, "drm.drmManager" },
{ AID_NFC, "nfc" },
{ AID_RADIO, "radio.phone" },
{ AID_RADIO, "radio.sms" },
{ AID_RADIO, "radio.phonesubinfo" },

10
core/java/android/content/Context.java
View File

@@ -1554,16 +1554,6 @@ public abstract class Context {
/** @hide */
public static final String SIP_SERVICE = "sip";
/**
* Use with {@link #getSystemService} to retrieve an
* {@link com.trustedlogic.trustednfc.android.INfcManager.INfcManager} for
* accessing NFC methods.
*
* @see #getSystemService
* @hide
*/
public static final String NFC_SERVICE = "nfc";
/**
* Determine whether the given permission is allowed for a particular
* process and user ID running in the system.

6
core/java/android/nfc/NfcAdapter.java
View File

@@ -166,10 +166,10 @@ public final class NfcAdapter {
}
sIsInitialized = true;
// TODO(npelly): check which method to use here to get the service
IBinder b = ServiceManager.getService(Context.NFC_SERVICE);
IBinder b = ServiceManager.getService("nfc");
if (b == null) {
return null; // This device does not have NFC
Log.d(TAG, "NFC Service not available");
return null;
}
sAdapter = new NfcAdapter(INfcAdapter.Stub.asInterface(b));

6
core/java/android/os/Process.java
View File

@@ -85,6 +85,12 @@ public class Process {
*/
public static final int WIFI_UID = 1010;
/**
* Defines the UID/GID for the NFC service process.
* @hide
*/
public static final int NFC_UID = 1022;
/**
* Defines the start of a range of UIDs (and GIDs), going from this
* number to {@link #LAST_APPLICATION_UID} that are reserved for assigning

68
core/java/com/trustedlogic/trustednfc/android/internal/NativeLlcpConnectionlessSocket.java
View File

@@ -1,68 +0,0 @@
/*
* Copyright (C) 2010 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* File : NativeLlcpConnectionLessSocket.java
* Original-Author : Trusted Logic S.A. (Sylvain Fonteneau)
* Created : 18-02-2010
*/
package com.trustedlogic.trustednfc.android.internal;
import android.nfc.LlcpPacket;
/**
* LlcpConnectionlessSocket represents a LLCP Connectionless object to be used
* in a connectionless communication
*
* @since AA02.01
* @hide
*/
public class NativeLlcpConnectionlessSocket {
private int mHandle;
private int mSap;
private int mLinkMiu;
public NativeLlcpConnectionlessSocket(){;
}
public NativeLlcpConnectionlessSocket(int sap){
mSap = sap;
}
public native boolean doSendTo(int sap, byte[] data);
public native LlcpPacket doReceiveFrom(int linkMiu);
public native boolean doClose();
public int getLinkMiu(){
return mLinkMiu;
}
public int getSap(){
return mSap;
}
public int getHandle(){
return mHandle;
}
}

82
core/java/com/trustedlogic/trustednfc/android/internal/NativeLlcpServiceSocket.java
View File

@@ -1,82 +0,0 @@
/*
* Copyright (C) 2010 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* File : NativeLlcpServerSocket.java
* Original-Author : Trusted Logic S.A. (Sylvain Fonteneau)
* Created : 18-02-2010
*/
package com.trustedlogic.trustednfc.android.internal;
/**
* LlcpServiceSocket represents a LLCP Service to be used in a
* Connection-oriented communication
* {@hide}
*/
public class NativeLlcpServiceSocket {
private int mHandle;
private int mLocalMiu;
private int mLocalRw;
private int mLocalLinearBufferLength;
private int mSap;
private int mTimeout;
private String mServiceName;
public NativeLlcpServiceSocket(){
}
public NativeLlcpServiceSocket(String serviceName){
mServiceName = serviceName;
}
public native NativeLlcpSocket doAccept(int timeout, int miu, int rw, int linearBufferLength);
public native boolean doClose();
public int getHandle(){
return mHandle;
}
public void setAcceptTimeout(int timeout){
mTimeout = timeout;
}
public int getAcceptTimeout(){
return mTimeout;
}
public int getRw(){
return mLocalRw;
}
public int getMiu(){
return mLocalMiu;
}
public int getLinearBufferLength(){
return mLocalLinearBufferLength;
}
}

93
core/java/com/trustedlogic/trustednfc/android/internal/NativeLlcpSocket.java
View File

@@ -1,93 +0,0 @@
/*
* Copyright (C) 2010 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* File : NativeLlcpClientSocket.java
* Original-Author : Trusted Logic S.A. (Sylvain Fonteneau)
* Created : 18-02-2010
*/
package com.trustedlogic.trustednfc.android.internal;
/**
* LlcpClientSocket represents a LLCP Connection-Oriented client to be used in a
* connection-oriented communication
* @hide
*/
public class NativeLlcpSocket {
private int mHandle;
private int mSap;
private int mLocalMiu;
private int mLocalRw;
private int mTimeout;
public NativeLlcpSocket(){
}
public NativeLlcpSocket(int sap, int miu, int rw){
mSap = sap;
mLocalMiu = miu;
mLocalRw = rw;
}
public native boolean doConnect(int nSap, int timeout);
public native boolean doConnectBy(String sn, int timeout);
public native boolean doClose();
public native boolean doSend(byte[] data);
public native int doReceive(byte[] recvBuff);
public native int doGetRemoteSocketMiu();
public native int doGetRemoteSocketRw();
public void setConnectTimeout(int timeout){
mTimeout = timeout;
}
public int getConnectTimeout(){
return mTimeout;
}
public int getSap(){
return mSap;
}
public int getMiu(){
return mLocalMiu;
}
public int getRw(){
return mLocalRw;
}
public int getHandle(){
return mHandle;
}
}

36
core/java/com/trustedlogic/trustednfc/android/internal/NativeNdefTag.java
View File

@@ -1,36 +0,0 @@
/*
* Copyright (C) 2010 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* File : NativeNdefTag.java
* Original-Author : Trusted Logic S.A. (Sylvain Fonteneau)
* Created : 18-02-2010
*/
package com.trustedlogic.trustednfc.android.internal;
/**
* Native interface to the NDEF tag functions
*
* @hide
*/
public class NativeNdefTag {
private int mHandle;
public native byte[] doRead();
public native boolean doWrite(byte[] buf);
}

369
core/java/com/trustedlogic/trustednfc/android/internal/NativeNfcManager.java
View File

@@ -1,369 +0,0 @@
/*
* Copyright (C) 2010 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* File : NativeNfcManager.java
* Original-Author : Trusted Logic S.A. (Sylvain Fonteneau)
* Created : 18-02-2010
*/
package com.trustedlogic.trustednfc.android.internal;
import android.annotation.SdkConstant;
import android.annotation.SdkConstant.SdkConstantType;
import android.content.ActivityNotFoundException;
import android.content.Context;
import android.content.Intent;
import android.os.Handler;
import android.os.Message;
import android.util.Log;
import android.nfc.FormatException;
import android.nfc.NdefTag;
import android.nfc.NfcAdapter;
import android.nfc.NdefMessage;
import android.nfc.Tag;
/**
* Native interface to the NFC Manager functions
* @hide
*/
public class NativeNfcManager {
@SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
public static final String INTERNAL_LLCP_LINK_STATE_CHANGED_EXTRA = "com.trustedlogic.trustednfc.android.extra.INTERNAL_LLCP_LINK_STATE";
@SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
public static final String INTERNAL_LLCP_LINK_STATE_CHANGED_ACTION = "com.trustedlogic.trustednfc.android.action.INTERNAL_LLCP_LINK_STATE_CHANGED";
@SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
public static final String INTERNAL_TARGET_DESELECTED_ACTION = "com.trustedlogic.trustednfc.android.action.INTERNAL_TARGET_DESELECTED";
/* Native structure */
private int mNative;
private final Context mContext;
private final Handler mNfcHandler;
private static final String TAG = "NativeNfcManager";
private static final int MSG_NDEF_TAG = 0;
private static final int MSG_CARD_EMULATION = 1;
private static final int MSG_LLCP_LINK_ACTIVATION = 2;
private static final int MSG_LLCP_LINK_DEACTIVATED = 3;
private static final int MSG_TARGET_DESELECTED = 4;
public NativeNfcManager(Context context) {
mNfcHandler = new NfcHandler();
mContext = context;
}
/**
* Initializes Native structure
*/
public native boolean initializeNativeStructure();
/**
* Initializes NFC stack.
*/
public native boolean initialize();
/**
* Deinitializes NFC stack.
*/
public native boolean deinitialize();
/**
* Enable discory for the NdefMessage and Transaction notification
*/
public native void enableDiscovery(int mode);
public native void disableDiscovery();
public native void readerDiscovery();
/**
* Disables an NFCManager mode of operation. Allows to disable tag reader,
* peer to peer initiator or target modes.
*
* @param mode discovery mode to enable. Must be one of the provided
* NFCManager.DISCOVERY_MODE_* constants.
*/
public native void disableDiscoveryMode(int mode);
public native int[] doGetSecureElementList();
public native void doSelectSecureElement(int seID);
public native void doDeselectSecureElement(int seID);
public native NativeP2pDevice doOpenP2pConnection(int timeout);
public native NativeNfcTag doOpenTagConnection(int timeout);
public native int doGetLastError();
public native void doSetProperties(int param, int value);
public native void doCancel();
public native NativeLlcpConnectionlessSocket doCreateLlcpConnectionlessSocket(int nSap);
public native NativeLlcpServiceSocket doCreateLlcpServiceSocket(int nSap, String sn, int miu,
int rw, int linearBufferLength);
public native NativeLlcpSocket doCreateLlcpSocket(int sap, int miu, int rw,
int linearBufferLength);
public native boolean doCheckLlcp();
public native boolean doActivateLlcp();
private class NfcHandler extends Handler {
private int convertType(String typeName) {
if (typeName.equals("Iso14443")) {
return Tag.NFC_TAG_ISO14443_4B;
} else if (typeName.equals("MifareUL")) {
return Tag.NFC_TAG_MIFARE;
} else if (typeName.equals("Mifare1K")) {
return Tag.NFC_TAG_MIFARE;
} else if (typeName.equals("Mifare4K")) {
return Tag.NFC_TAG_MIFARE;
} else if (typeName.equals("MifareDESFIRE")) {
return Tag.NFC_TAG_MIFARE;
} else if (typeName.equals("Unknown Mifare")) {
return Tag.NFC_TAG_MIFARE;
} else if (typeName.equals("Felica")) {
return Tag.NFC_TAG_FELICA;
} else if (typeName.equals("Jewel")) {
return Tag.NFC_TAG_JEWEL;
} else {
return Tag.NFC_TAG_OTHER;
}
}
@Override
public void handleMessage(Message msg) {
try {
switch (msg.what) {
case MSG_NDEF_TAG:
Log.d(TAG, "Tag detected, notifying applications");
NativeNfcTag nativeTag = (NativeNfcTag) msg.obj;
if (nativeTag.doConnect()) {
if (nativeTag.checkNDEF()) {
byte[] buff = nativeTag.doRead();
if (buff != null) {
NdefMessage[] msgNdef = new NdefMessage[1];
try {
msgNdef[0] = new NdefMessage(buff);
NdefTag tag = new NdefTag(convertType(nativeTag.getType()), nativeTag.getUid(), nativeTag.getHandle(), msgNdef);
Intent intent = new Intent();
intent.setAction(NfcAdapter.ACTION_NDEF_TAG_DISCOVERED);
intent.putExtra(NfcAdapter.EXTRA_TAG, tag);
intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
Log.d(TAG, "NDEF tag found, starting corresponding activity");
try {
mContext.startActivity(intent);
} catch (ActivityNotFoundException e) {
Log.w(TAG, "No activity found, disconnecting");
nativeTag.doAsyncDisconnect();
}
} catch (FormatException e) {
Log.w(TAG, "Unable to create NDEF message object (tag empty or not well formated)");
nativeTag.doAsyncDisconnect();
}
} else {
Log.w(TAG, "Unable to read NDEF message (tag empty or not well formated)");
nativeTag.doAsyncDisconnect();
}
} else {
Intent intent = new Intent();
Tag tag = new Tag(convertType(nativeTag.getType()), false, nativeTag.getUid(), nativeTag.getHandle());
intent.setAction(NfcAdapter.ACTION_TAG_DISCOVERED);
intent.putExtra(NfcAdapter.EXTRA_TAG, tag);
intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
Log.d(TAG, "Non-NDEF tag found, starting corresponding activity");
try {
mContext.startActivity(intent);
} catch (ActivityNotFoundException e) {
Log.w(TAG, "No activity found, disconnecting");
nativeTag.doAsyncDisconnect();
}
}
} else {
Log.w(TAG, "Failed to connect to tag");
nativeTag.doAsyncDisconnect();
}
break;
case MSG_CARD_EMULATION:
Log.d(TAG, "Card Emulation message");
byte[] aid = (byte[]) msg.obj;
/* Send broadcast ordered */
Intent TransactionIntent = new Intent();
TransactionIntent.setAction(NfcAdapter.ACTION_TRANSACTION_DETECTED);
TransactionIntent.putExtra(NfcAdapter.EXTRA_AID, aid);
Log.d(TAG, "Broadcasting Card Emulation event");
mContext.sendOrderedBroadcast(TransactionIntent,
android.Manifest.permission.NFC_NOTIFY);
break;
case MSG_LLCP_LINK_ACTIVATION:
NativeP2pDevice device = (NativeP2pDevice) msg.obj;
Log.d(TAG, "LLCP Activation message");
if (device.getMode() == NativeP2pDevice.MODE_P2P_TARGET) {
if (device.doConnect()) {
/* Check Llcp compliancy */
if (doCheckLlcp()) {
/* Activate Llcp Link */
if (doActivateLlcp()) {
Log.d(TAG, "Initiator Activate LLCP OK");
/* Broadcast Intent Link LLCP activated */
Intent LlcpLinkIntent = new Intent();
LlcpLinkIntent
.setAction(INTERNAL_LLCP_LINK_STATE_CHANGED_ACTION);
LlcpLinkIntent.putExtra(
INTERNAL_LLCP_LINK_STATE_CHANGED_EXTRA,
NfcAdapter.LLCP_LINK_STATE_ACTIVATED);
Log.d(TAG, "Broadcasting internal LLCP activation");
mContext.sendBroadcast(LlcpLinkIntent);
}
} else {
device.doDisconnect();
}
}
} else if (device.getMode() == NativeP2pDevice.MODE_P2P_INITIATOR) {
/* Check Llcp compliancy */
if (doCheckLlcp()) {
/* Activate Llcp Link */
if (doActivateLlcp()) {
Log.d(TAG, "Target Activate LLCP OK");
/* Broadcast Intent Link LLCP activated */
Intent LlcpLinkIntent = new Intent();
LlcpLinkIntent
.setAction(INTERNAL_LLCP_LINK_STATE_CHANGED_ACTION);
LlcpLinkIntent.putExtra(INTERNAL_LLCP_LINK_STATE_CHANGED_EXTRA,
NfcAdapter.LLCP_LINK_STATE_ACTIVATED);
Log.d(TAG, "Broadcasting internal LLCP activation");
mContext.sendBroadcast(LlcpLinkIntent);
}
}
}
break;
case MSG_LLCP_LINK_DEACTIVATED:
/* Broadcast Intent Link LLCP activated */
Log.d(TAG, "LLCP Link Deactivated message");
Intent LlcpLinkIntent = new Intent();
LlcpLinkIntent.setAction(NfcAdapter.ACTION_LLCP_LINK_STATE_CHANGED);
LlcpLinkIntent.putExtra(NfcAdapter.EXTRA_LLCP_LINK_STATE_CHANGED,
NfcAdapter.LLCP_LINK_STATE_DEACTIVATED);
Log.d(TAG, "Broadcasting LLCP deactivation");
mContext.sendOrderedBroadcast(LlcpLinkIntent,
android.Manifest.permission.NFC_LLCP);
break;
case MSG_TARGET_DESELECTED:
/* Broadcast Intent Target Deselected */
Log.d(TAG, "Target Deselected");
Intent TargetDeselectedIntent = new Intent();
TargetDeselectedIntent.setAction(INTERNAL_TARGET_DESELECTED_ACTION);
Log.d(TAG, "Broadcasting Intent");
mContext.sendOrderedBroadcast(TargetDeselectedIntent,
android.Manifest.permission.NFC_LLCP);
break;
default:
Log.e(TAG, "Unknown message received");
break;
}
} catch (Exception e) {
// Log, don't crash!
Log.e(TAG, "Exception in NfcHandler.handleMessage:", e);
}
}
};
/**
* Notifies Ndef Message
*/
private void notifyNdefMessageListeners(NativeNfcTag tag) {
Message msg = mNfcHandler.obtainMessage();
msg.what = MSG_NDEF_TAG;
msg.obj = tag;
mNfcHandler.sendMessage(msg);
}
/**
* Notifies transaction
*/
private void notifyTargetDeselected() {
Message msg = mNfcHandler.obtainMessage();
msg.what = MSG_TARGET_DESELECTED;
mNfcHandler.sendMessage(msg);
}
/**
* Notifies transaction
*/
private void notifyTransactionListeners(byte[] aid) {
Message msg = mNfcHandler.obtainMessage();
msg.what = MSG_CARD_EMULATION;
msg.obj = aid;
mNfcHandler.sendMessage(msg);
}
/**
* Notifies P2P Device detected, to activate LLCP link
*/
private void notifyLlcpLinkActivation(NativeP2pDevice device) {
Message msg = mNfcHandler.obtainMessage();
msg.what = MSG_LLCP_LINK_ACTIVATION;
msg.obj = device;
mNfcHandler.sendMessage(msg);
}
/**
* Notifies P2P Device detected, to activate LLCP link
*/
private void notifyLlcpLinkDeactivated() {
Message msg = mNfcHandler.obtainMessage();
msg.what = MSG_LLCP_LINK_DEACTIVATED;
mNfcHandler.sendMessage(msg);
}
}

71
core/java/com/trustedlogic/trustednfc/android/internal/NativeNfcTag.java
View File

@@ -1,71 +0,0 @@
/*
* Copyright (C) 2010 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* File : NativeNfcTag.java
* Original-Author : Trusted Logic S.A. (Sylvain Fonteneau)
* Created : 18-02-2010
*/
package com.trustedlogic.trustednfc.android.internal;
/**
* Native interface to the NFC tag functions
*
* @hide
*/
public class NativeNfcTag {
private int mHandle;
private String mType;
private byte[] mUid;
public native boolean doConnect();
public native boolean doDisconnect();
public native void doAsyncDisconnect();
public native byte[] doTransceive(byte[] data);
public native boolean checkNDEF();
public native byte[] doRead();
public native boolean doWrite(byte[] buf);
private NativeNfcTag() {
}
public NativeNfcTag(int handle, String type, byte[] uid) {
mHandle = handle;
mType = type;
mUid = uid.clone();
}
public int getHandle() {
return mHandle;
}
public String getType() {
return mType;
}
public byte[] getUid() {
return mUid;
}
}

75
core/java/com/trustedlogic/trustednfc/android/internal/NativeP2pDevice.java
View File

@@ -1,75 +0,0 @@
/*
* Copyright (C) 2010 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* File : NativeP2pDevice.java
* Original-Author : Trusted Logic S.A. (Sylvain Fonteneau)
* Created : 18-02-2010
*/
package com.trustedlogic.trustednfc.android.internal;
/**
* Native interface to the P2P Initiator functions
*
* @hide
*/
public class NativeP2pDevice {
/**
* Peer-to-Peer Target.
*/
public static final short MODE_P2P_TARGET = 0x00;
/**
* Peer-to-Peer Initiator.
*/
public static final short MODE_P2P_INITIATOR = 0x01;
/**
* Invalid target type.
*/
public static final short MODE_INVALID = 0xff;
private int mHandle;
private int mMode;
private byte[] mGeneralBytes;
public native byte[] doReceive();
public native boolean doSend(byte[] data);
public native boolean doConnect();
public native boolean doDisconnect();
public native byte[] doTransceive(byte[] data);
public int getHandle() {
return mHandle;
}
public int getMode() {
return mMode;
}
public byte[] getGeneralBytes() {
return mGeneralBytes;
}
}

13
core/jni/Android.mk
View File

@@ -67,6 +67,8 @@ LOCAL_SRC_FILES:= \
android_net_TrafficStats.cpp \
android_net_wifi_Wifi.cpp \
android_nio_utils.cpp \
android_nfc_NdefMessage.cpp \
android_nfc_NdefRecord.cpp \
android_pim_EventRecurrence.cpp \
android_text_format_Time.cpp \
android_security_Md5MessageDigest.cpp \
@@ -190,15 +192,8 @@ LOCAL_SHARED_LIBRARIES := \
libicui18n \
libmedia \
libwpa_client \
libjpeg
ifeq ($(BOARD_HAVE_NFC),true)
LOCAL_SHARED_LIBRARIES += \
libnfc_jni \
libnfc
LOCAL_CFLAGS += -DHAVE_NFC
endif
libjpeg \
libnfc_ndef
ifeq ($(BOARD_HAVE_BLUETOOTH),true)
LOCAL_C_INCLUDES += \

28
core/jni/AndroidRuntime.cpp
View File

@@ -125,6 +125,8 @@ extern int register_android_database_SQLiteQuery(JNIEnv* env);
extern int register_android_database_SQLiteStatement(JNIEnv* env);
extern int register_android_debug_JNITest(JNIEnv* env);
extern int register_android_nio_utils(JNIEnv* env);
extern int register_android_nfc_NdefMessage(JNIEnv *env);
extern int register_android_nfc_NdefRecord(JNIEnv *env);
extern int register_android_pim_EventRecurrence(JNIEnv* env);
extern int register_android_text_format_Time(JNIEnv* env);
extern int register_android_os_Debug(JNIEnv* env);
@@ -169,18 +171,6 @@ extern int register_android_view_MotionEvent(JNIEnv* env);
extern int register_android_content_res_ObbScanner(JNIEnv* env);
extern int register_android_content_res_Configuration(JNIEnv* env);
#ifdef HAVE_NFC
extern int register_com_trustedlogic_trustednfc_android_internal_NativeNfcManager(JNIEnv *env);
extern int register_com_trustedlogic_trustednfc_android_internal_NativeNfcTag(JNIEnv *env);
extern int register_com_trustedlogic_trustednfc_android_internal_NativeNdefTag(JNIEnv *env);
extern int register_com_trustedlogic_trustednfc_android_NdefMessage(JNIEnv *env);
extern int register_com_trustedlogic_trustednfc_android_NdefRecord(JNIEnv *env);
extern int register_com_trustedlogic_trustednfc_android_internal_NativeP2pDevice(JNIEnv *env);
extern int register_com_trustedlogic_trustednfc_android_internal_NativeLlcpSocket(JNIEnv *env);
extern int register_com_trustedlogic_trustednfc_android_internal_NativeLlcpConnectionlessSocket(JNIEnv *env);
extern int register_com_trustedlogic_trustednfc_android_internal_NativeLlcpServiceSocket(JNIEnv *env);
#endif
static AndroidRuntime* gCurRuntime = NULL;
static void doThrow(JNIEnv* env, const char* exc, const char* msg = NULL)
@@ -1263,6 +1253,8 @@ static const RegJNIRec gRegJNI[] = {
REG_JNI(register_android_net_NetworkUtils),
REG_JNI(register_android_net_TrafficStats),
REG_JNI(register_android_net_wifi_WifiManager),
REG_JNI(register_android_nfc_NdefMessage),
REG_JNI(register_android_nfc_NdefRecord),
REG_JNI(register_android_os_MemoryFile),
REG_JNI(register_com_android_internal_os_ZygoteInit),
REG_JNI(register_android_hardware_Camera),
@@ -1297,18 +1289,6 @@ static const RegJNIRec gRegJNI[] = {
REG_JNI(register_android_content_res_ObbScanner),
REG_JNI(register_android_content_res_Configuration),
#ifdef HAVE_NFC
REG_JNI(register_com_trustedlogic_trustednfc_android_internal_NativeNfcManager),
REG_JNI(register_com_trustedlogic_trustednfc_android_internal_NativeNfcTag),
REG_JNI(register_com_trustedlogic_trustednfc_android_internal_NativeNdefTag),
REG_JNI(register_com_trustedlogic_trustednfc_android_NdefMessage),
REG_JNI(register_com_trustedlogic_trustednfc_android_NdefRecord),
REG_JNI(register_com_trustedlogic_trustednfc_android_internal_NativeP2pDevice),
REG_JNI(register_com_trustedlogic_trustednfc_android_internal_NativeLlcpSocket),
REG_JNI(register_com_trustedlogic_trustednfc_android_internal_NativeLlcpConnectionlessSocket),
REG_JNI(register_com_trustedlogic_trustednfc_android_internal_NativeLlcpServiceSocket),
#endif
};
/*

54
core/jni/android_nfc.h Normal file
View File

@@ -0,0 +1,54 @@
/*
* Copyright (C) 2010 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/*
* Contains the bare minimum header so that framework NFC jni can link
* against NFC native library
*/
#ifndef __ANDROID_NFC_H__
#define __ANDROID_NFC_H__
extern "C" {
typedef struct phFriNfc_NdefRecord {
uint8_t Flags;
uint8_t Tnf;
uint8_t TypeLength;
uint8_t *Type;
uint8_t IdLength;
uint8_t *Id;
uint32_t PayloadLength;
uint8_t *PayloadData;
} phFriNfc_NdefRecord_t;
uint16_t phFriNfc_NdefRecord_GetRecords(uint8_t* pBuffer,
uint32_t BufferLength,
uint8_t* pRawRecords[ ],
uint8_t IsChunked[ ],
uint32_t* pNumberOfRawRecords
);
uint16_t phFriNfc_NdefRecord_Parse(phFriNfc_NdefRecord_t* pRecord,
uint8_t* pRawRecord);
uint16_t phFriNfc_NdefRecord_Generate(phFriNfc_NdefRecord_t* pRecord,
uint8_t* pBuffer,
uint32_t MaxBufferSize,
uint32_t* pBytesWritten
);
}
#endif

175
core/jni/android_nfc_NdefMessage.cpp Normal file
View File

@@ -0,0 +1,175 @@
/*
* Copyright (C) 2010 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#define LOG_TAG "NdefMessage"
#include "jni.h"
#include "JNIHelp.h"
#include "android_nfc.h"
#include <utils/Log.h>
namespace android {
static jint android_nfc_NdefMessage_parseNdefMessage(JNIEnv *e, jobject o,
jbyteArray array)
{
uint16_t status;
uint32_t i;
jbyte *raw_msg;
jsize raw_msg_size;
uint32_t num_of_records = 0;
uint8_t **records = NULL;
uint8_t *is_chunked = NULL;
jint ret = -1;
phFriNfc_NdefRecord_t record;
jclass record_cls;
jobjectArray records_array;
jmethodID ctor;
jclass msg_cls;
jfieldID mrecords;
raw_msg_size = e->GetArrayLength(array);
raw_msg = e->GetByteArrayElements(array, NULL);
if (raw_msg == NULL)
return -1;
/* Get the number of records in the message so we can allocate buffers */
LOGD("phFriNfc_NdefRecord_GetRecords(NULL)");
status = phFriNfc_NdefRecord_GetRecords((uint8_t *)raw_msg,
(uint32_t)raw_msg_size, NULL, NULL, &num_of_records);
if (status) {
LOGE("phFriNfc_NdefRecord_GetRecords(NULL) returned 0x%04x", status);
goto end;
}
LOGD("phFriNfc_NdefRecord_GetRecords(NULL) returned 0x%04x", status);
LOGD("found %d records in message", num_of_records);
is_chunked = (uint8_t*)malloc(num_of_records);
if (is_chunked == NULL)
goto end;
records = (uint8_t**)malloc(num_of_records * sizeof(uint8_t *));
if (records == NULL)
goto end;
/* Now, actually retrieve records position in message */
LOGD("phFriNfc_NdefRecord_GetRecords()");
status = phFriNfc_NdefRecord_GetRecords((uint8_t *)raw_msg,
(uint32_t)raw_msg_size, records, is_chunked, &num_of_records);
if (status) {
LOGE("phFriNfc_NdefRecord_GetRecords() returned 0x%04x", status);
goto end;
}
LOGD("phFriNfc_NdefRecord_GetRecords() returned 0x%04x", status);
/* Build NDEF records array */
record_cls = e->FindClass("android/nfc/NdefRecord");
records_array = e->NewObjectArray((jsize)num_of_records, record_cls,
NULL);
if (records_array == NULL)
goto end;
ctor = e->GetMethodID(record_cls, "<init>", "(S[B[B[B)V");
LOGD("NFC_Number of records = %d\n", num_of_records);
for (i = 0; i < num_of_records; i++) {
jbyteArray type, id, payload;
jobject new_record;
LOGD("phFriNfc_NdefRecord_Parse()");
status = phFriNfc_NdefRecord_Parse(&record, records[i]);
if (status) {
LOGE("phFriNfc_NdefRecord_Parse() returned 0x%04x", status);
goto end;
}
LOGD("phFriNfc_NdefRecord_Parse() returned 0x%04x", status);
type = e->NewByteArray(record.TypeLength);
if (type == NULL) {
LOGD("NFC_Set Record Type Error\n");
goto end;
}
id = e->NewByteArray(record.IdLength);
if(id == NULL) {
LOGD("NFC_Set Record ID Error\n");
goto end;
}
payload = e->NewByteArray(record.PayloadLength);
if(payload == NULL) {
LOGD("NFC_Set Record Payload Error\n");
goto end;
}
e->SetByteArrayRegion(type, 0, record.TypeLength,
(jbyte *)record.Type);
e->SetByteArrayRegion(id, 0, record.IdLength,
(jbyte *)record.Id);
e->SetByteArrayRegion(payload, 0, record.PayloadLength,
(jbyte *)record.PayloadData);
new_record = e->NewObject(record_cls, ctor,
(jshort)record.Tnf, type, id, payload);
e->SetObjectArrayElement(records_array, i, new_record);
/* Try not to clutter the Java stack too much */
e->DeleteLocalRef(new_record);
e->DeleteLocalRef(type);
e->DeleteLocalRef(id);
e->DeleteLocalRef(payload);
}
/* Store built array in our NDEFMessage instance */
msg_cls = e->GetObjectClass(o);
mrecords = e->GetFieldID(msg_cls, "mRecords", "[Landroid/nfc/NdefRecord;");
e->SetObjectField(o, mrecords, (jobject)records_array);
ret = 0;
end:
if(is_chunked)
free(is_chunked);
if(records)
free(records);
e->ReleaseByteArrayElements(array, raw_msg, JNI_ABORT);
return ret;
}
static JNINativeMethod gMethods[] = {
{"parseNdefMessage", "([B)I", (void *)android_nfc_NdefMessage_parseNdefMessage},
};
int register_android_nfc_NdefMessage(JNIEnv *e)
{
return jniRegisterNativeMethods(e, "android/nfc/NdefMessage", gMethods, NELEM(gMethods));
}
} // namespace android

92
core/jni/android_nfc_NdefRecord.cpp Normal file
View File

@@ -0,0 +1,92 @@
/*
* Copyright (C) 2010 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#define LOG_TAG "NdefRecord"
#include "jni.h"
#include "JNIHelp.h"
#include "android_nfc.h"
#include <utils/Log.h>
namespace android {
static jbyteArray android_nfc_NdefRecord_generate(
JNIEnv *e, jobject o, jshort flags, jshort tnf, jbyteArray type,
jbyteArray id, jbyteArray payload)
{
uint32_t status;
phFriNfc_NdefRecord_t record;
uint32_t buf_size;
uint32_t record_size;
uint8_t *buf = NULL;
jbyteArray result = NULL;
/* Prepare NDEF record structure */
record.Flags = (uint8_t)flags;
record.Tnf = (uint8_t)tnf;
record.TypeLength = (uint32_t)e->GetArrayLength(type);
record.Type = (uint8_t *)e->GetByteArrayElements(type, NULL);
record.IdLength = (uint32_t)e->GetArrayLength(id);
record.Id = (uint8_t *)e->GetByteArrayElements(id, NULL);
record.PayloadLength = (uint32_t)e->GetArrayLength(payload);
record.PayloadData = (uint8_t *)e->GetByteArrayElements(payload, NULL);
buf_size = record.PayloadLength + record.IdLength + record.TypeLength + 8;
buf = (uint8_t*)malloc(buf_size);
if (buf == NULL)
goto end;
LOGD("phFriNfc_NdefRecord_Generate()");
status = phFriNfc_NdefRecord_Generate(&record, buf, buf_size,
&record_size);
if (status) {
LOGE("phFriNfc_NdefRecord_Generate() returned 0x%04x", status);
goto end;
}
LOGD("phFriNfc_NdefRecord_Generate() returned 0x%04x", status);
result = e->NewByteArray(record_size);
if (result == NULL)
goto end;
e->SetByteArrayRegion(result, 0, record_size, (jbyte *)buf);
end:
e->ReleaseByteArrayElements(type, (jbyte *)record.Type, JNI_ABORT);
e->ReleaseByteArrayElements(id, (jbyte *)record.Id, JNI_ABORT);
e->ReleaseByteArrayElements(payload, (jbyte *)record.PayloadData, JNI_ABORT);
if(buf)
free(buf);
return result;
}
static JNINativeMethod gMethods[] = {
{"generate", "(SS[B[B[B)[B", (void *)android_nfc_NdefRecord_generate},
};
int register_android_nfc_NdefRecord(JNIEnv *e)
{
return jniRegisterNativeMethods(e, "android/nfc/NdefRecord", gMethods, NELEM(gMethods));
}
} // namespace android

5
services/java/com/android/server/PackageManagerService.java
View File

@@ -144,6 +144,7 @@ class PackageManagerService extends IPackageManager.Stub {
private static final boolean MULTIPLE_APPLICATION_UIDS = true;
private static final int RADIO_UID = Process.PHONE_UID;
private static final int LOG_UID = Process.LOG_UID;
private static final int NFC_UID = Process.NFC_UID;
private static final int FIRST_APPLICATION_UID =
Process.FIRST_APPLICATION_UID;
private static final int MAX_APPLICATION_UIDS = 1000;
@@ -740,6 +741,10 @@ class PackageManagerService extends IPackageManager.Stub {
MULTIPLE_APPLICATION_UIDS
? LOG_UID : FIRST_APPLICATION_UID,
ApplicationInfo.FLAG_SYSTEM);
mSettings.addSharedUserLP("android.uid.nfc",
MULTIPLE_APPLICATION_UIDS
? NFC_UID : FIRST_APPLICATION_UID,
ApplicationInfo.FLAG_SYSTEM);
String separateProcesses = SystemProperties.get("debug.separate_processes");
if (separateProcesses != null && separateProcesses.length() > 0) {

15
services/java/com/android/server/SystemServer.java
View File

@@ -20,7 +20,6 @@ import com.android.server.am.ActivityManagerService;
import com.android.internal.app.ShutdownThread;
import com.android.internal.os.BinderInternal;
import com.android.internal.os.SamplingProfilerIntegration;
import com.trustedlogic.trustednfc.android.server.NfcService;
import dalvik.system.VMRuntime;
import dalvik.system.Zygote;
@@ -436,20 +435,6 @@ class ServerThread extends Thread {
Slog.e(TAG, "Failure starting Recognition Service", e);
}
try {
Slog.i(TAG, "Nfc Service");
NfcService nfc;
try {
nfc = new NfcService(context);
} catch (UnsatisfiedLinkError e) { // gross hack to detect NFC
nfc = null;
Slog.w(TAG, "No NFC support");
}
ServiceManager.addService(Context.NFC_SERVICE, nfc);
} catch (Throwable e) {
Slog.e(TAG, "Failure starting NFC Service", e);
}
try {
Slog.i(TAG, "DiskStats Service");
ServiceManager.addService("diskstats", new DiskStatsService(context));

2157
services/java/com/trustedlogic/trustednfc/android/server/NfcService.java
View File

File diff suppressed because it is too large Load Diff