요즘 스마트폰으로 교통카드 찍고, 결제하고, 출입문 열고 하는 거 다들 자연스럽게 쓰고 있죠?ㅋㅋㅋ 이게 다 NFC 기술 덕분인데요! 💳

근데 막상 이걸 직접 개발하려고 하면 "어? 생각보다 복잡한데?" 하는 분들이 많더라고요. 특히 NFC 태그 읽고 쓰는 기능 구현할 때 말이죠.

오늘은 실제로 동작하는 NFC 태그 읽기/쓰기 응용 소스코드를 완전 파헤쳐볼 거예요! 이론만 주구장창 늘어놓는 게 아니라, 진짜 복붙해서 쓸 수 있는 실전 코드 위주로 설명드릴게요 😎

본격적으로 코드 들어가기 전에 NFC가 뭔지부터 간단하게 정리하고 갈게요!ㅋㅋ

NFC(Near Field Communication)는 말 그대로 '근거리 무선 통신' 기술이에요. 보통 10cm 이내의 짧은 거리에서 데이터를 주고받는 방식인데, 블루투스나 WiFi보다 훨씬 가까운 거리에서만 작동하죠.

이게 오히려 장점이에요! 보안이 좋고, 빠르고, 전력 소모도 적거든요 💪

NFC는 크게 세 가지 모드로 동작해요:

우리가 집중할 건 Reader/Writer 모드예요. 이게 가장 기본이면서도 활용도가 높거든요 🎨

자, 이제 본격적으로 개발 들어가볼까요? 먼저 필요한 것들부터 체크해봅시다!

필수 준비물:
✅ Android Studio (최신 버전 권장)
✅ NFC 기능이 있는 안드로이드 폰 (테스트용)
✅ NFC 태그 몇 개 (다이소나 온라인에서 저렴하게 구입 가능ㅋㅋ)
✅ 최소 SDK 버전: API 19 (Android 4.4) 이상

요즘 나오는 스마트폰은 거의 다 NFC 지원하니까 크게 걱정 안 해도 돼요!

가장 먼저 해야 할 건 매니페스트 파일에 NFC 권한과 기능을 선언하는 거예요. 이거 안 하면 아무것도 안 돼요ㅋㅋㅋ

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.nfcapp">

    <!-- NFC 권한 선언 -->
    <uses-permission android:name="android.permission.NFC" />
    
    <!-- NFC 기능 필수 여부 설정 -->
    <uses-feature
        android:name="android.hardware.nfc"
        android:required="true" />

    <application
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:theme="@style/AppTheme">
        
        <activity
            android:name=".MainActivity"
            android:launchMode="singleTop"
            android:exported="true">
            
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
            
            <!-- NFC 태그 감지 인텐트 필터 -->
            <intent-filter>
                <action android:name="android.nfc.action.NDEF_DISCOVERED" />
                <category android:name="android.intent.category.DEFAULT" />
                <data android:mimeType="text/plain" />
            </intent-filter>
            
            <intent-filter>
                <action android:name="android.nfc.action.TAG_DISCOVERED" />
                <category android:name="android.intent.category.DEFAULT" />
            </intent-filter>
            
        </activity>
    </application>

</manifest>

여기서 중요한 포인트 몇 가지 짚고 넘어갈게요!

launchMode="singleTop" 이 부분 진짜 중요해요! 이거 안 하면 NFC 태그 읽을 때마다 액티비티가 새로 생성돼서 난리 나거든요ㅋㅋㅋ

인텐트 필터는 두 가지를 등록했어요:
- NDEF_DISCOVERED: NDEF 포맷으로 저장된 데이터를 읽을 때
- TAG_DISCOVERED: 포맷되지 않은 태그나 다른 형식의 태그를 읽을 때

이렇게 하면 거의 모든 NFC 태그를 감지할 수 있어요 👍

UI는 심플하게 가볼게요. 실제로는 더 예쁘게 꾸미겠지만, 기능 이해에 집중하기 위해 필수 요소만 넣었어요!

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    android:padding="16dp"
    android:gravity="center_horizontal">

    <TextView
        android:id="@+id/tvStatus"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="NFC 태그를 가까이 대주세요"
        android:textSize="18sp"
        android:textStyle="bold"
        android:layout_marginTop="32dp"
        android:textColor="#558b2f" />

    <TextView
        android:id="@+id/tvTagInfo"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="태그 정보가 여기에 표시됩니다"
        android:textSize="14sp"
        android:layout_marginTop="24dp"
        android:padding="16dp"
        android:background="#f5f5f5"
        android:minHeight="120dp" />

    <EditText
        android:id="@+id/etWriteData"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:hint="태그에 쓸 내용을 입력하세요"
        android:layout_marginTop="24dp"
        android:padding="12dp"
        android:background="@android:drawable/edit_text" />

    <Button
        android:id="@+id/btnWrite"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="NFC 태그에 쓰기"
        android:layout_marginTop="16dp"
        android:backgroundTint="#66bb6a"
        android:textColor="#ffffff" />

    <Button
        android:id="@+id/btnClear"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="화면 지우기"
        android:layout_marginTop="8dp"
        android:backgroundTint="#bdbdbd"
        android:textColor="#ffffff" />

</LinearLayout>

간단하죠? 상태 표시용 텍스트뷰, 태그 정보 표시용 텍스트뷰, 데이터 입력용 에디트텍스트, 그리고 쓰기/지우기 버튼만 있으면 돼요 ✨

자, 이제 진짜 핵심인 메인 액티비티 코드를 볼 차례예요! 먼저 NFC 태그 읽기 기능부터 구현해볼게요.

코드가 좀 길지만 하나하나 설명할 테니까 천천히 따라오세요 😊

package com.example.nfcapp;

import android.app.PendingIntent;
import android.content.Intent;
import android.content.IntentFilter;
import android.nfc.NdefMessage;
import android.nfc.NdefRecord;
import android.nfc.NfcAdapter;
import android.nfc.Tag;
import android.nfc.tech.Ndef;
import android.nfc.tech.NdefFormatable;
import android.os.Bundle;
import android.os.Parcelable;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
import android.widget.TextView;
import android.widget.Toast;
import androidx.appcompat.app.AppCompatActivity;
import java.io.IOException;
import java.nio.charset.Charset;

public class MainActivity extends AppCompatActivity {

    private NfcAdapter nfcAdapter;
    private PendingIntent pendingIntent;
    private IntentFilter[] intentFiltersArray;
    private String[][] techListsArray;
    
    private TextView tvStatus;
    private TextView tvTagInfo;
    private EditText etWriteData;
    private Button btnWrite;
    private Button btnClear;
    
    private boolean writeMode = false;
    private String dataToWrite = "";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        
        // UI 요소 초기화
        initViews();
        
        // NFC 어댑터 초기화
        initNFC();
        
        // 버튼 리스너 설정
        setupListeners();
        
        // 인텐트로 전달된 NFC 태그 처리
        handleIntent(getIntent());
    }
    
    private void initViews() {
        tvStatus = findViewById(R.id.tvStatus);
        tvTagInfo = findViewById(R.id.tvTagInfo);
        etWriteData = findViewById(R.id.etWriteData);
        btnWrite = findViewById(R.id.btnWrite);
        btnClear = findViewById(R.id.btnClear);
    }
    
    private void initNFC() {
        // NFC 어댑터 가져오기
        nfcAdapter = NfcAdapter.getDefaultAdapter(this);
        
        if (nfcAdapter == null) {
            // 기기가 NFC를 지원하지 않음
            tvStatus.setText("이 기기는 NFC를 지원하지 않습니다 😢");
            btnWrite.setEnabled(false);
            return;
        }
        
        if (!nfcAdapter.isEnabled()) {
            // NFC가 비활성화되어 있음
            tvStatus.setText("NFC가 꺼져있어요! 설정에서 켜주세요 🔧");
        }
        
        // PendingIntent 생성
        Intent intent = new Intent(this, getClass())
            .addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP);
        pendingIntent = PendingIntent.getActivity(
            this, 0, intent, PendingIntent.FLAG_MUTABLE);
        
        // IntentFilter 설정
        IntentFilter ndefFilter = new IntentFilter(NfcAdapter.ACTION_NDEF_DISCOVERED);
        try {
            ndefFilter.addDataType("text/plain");
        } catch (IntentFilter.MalformedMimeTypeException e) {
            throw new RuntimeException("MIME 타입 설정 실패", e);
        }
        
        intentFiltersArray = new IntentFilter[] { ndefFilter };
        
        // Tech List 설정
        techListsArray = new String[][] { 
            new String[] { Ndef.class.getName() },
            new String[] { NdefFormatable.class.getName() }
        };
    }
    
    private void setupListeners() {
        btnWrite.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                String data = etWriteData.getText().toString().trim();
                if (data.isEmpty()) {
                    Toast.makeText(MainActivity.this, 
                        "쓸 내용을 입력해주세요!", Toast.LENGTH_SHORT).show();
                    return;
                }
                
                dataToWrite = data;
                writeMode = true;
                tvStatus.setText("쓰기 모드 활성화! 태그를 가까이 대주세요 ✍️");
                Toast.makeText(MainActivity.this, 
                    "이제 NFC 태그를 가까이 대주세요", Toast.LENGTH_LONG).show();
            }
        });
        
        btnClear.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                tvTagInfo.setText("태그 정보가 여기에 표시됩니다");
                etWriteData.setText("");
                writeMode = false;
                tvStatus.setText("NFC 태그를 가까이 대주세요");
            }
        });
    }

    @Override
    protected void onResume() {
        super.onResume();
        if (nfcAdapter != null) {
            // Foreground Dispatch 활성화
            nfcAdapter.enableForegroundDispatch(
                this, pendingIntent, intentFiltersArray, techListsArray);
        }
    }

    @Override
    protected void onPause() {
        super.onPause();
        if (nfcAdapter != null) {
            // Foreground Dispatch 비활성화
            nfcAdapter.disableForegroundDispatch(this);
        }
    }

    @Override
    protected void onNewIntent(Intent intent) {
        super.onNewIntent(intent);
        handleIntent(intent);
    }
    
    private void handleIntent(Intent intent) {
        String action = intent.getAction();
        
        if (NfcAdapter.ACTION_NDEF_DISCOVERED.equals(action) ||
            NfcAdapter.ACTION_TAG_DISCOVERED.equals(action)) {
            
            Tag tag = intent.getParcelableExtra(NfcAdapter.EXTRA_TAG);
            
            if (writeMode) {
                // 쓰기 모드일 때
                writeToTag(tag, dataToWrite);
            } else {
                // 읽기 모드일 때
                readFromTag(intent, tag);
            }
        }
    }
    
    private void readFromTag(Intent intent, Tag tag) {
        // NDEF 메시지 읽기
        Parcelable[] rawMessages = 
            intent.getParcelableArrayExtra(NfcAdapter.EXTRA_NDEF_MESSAGES);
        
        StringBuilder tagInfo = new StringBuilder();
        tagInfo.append("📱 태그 정보\n\n");
        
        // 태그 ID 표시
        byte[] id = tag.getId();
        tagInfo.append("🆔 태그 ID: ").append(bytesToHex(id)).append("\n\n");
        
        // 지원 기술 표시
        String[] techList = tag.getTechList();
        tagInfo.append("🔧 지원 기술:\n");
        for (String tech : techList) {
            String techName = tech.substring(tech.lastIndexOf(".") + 1);
            tagInfo.append("  • ").append(techName).append("\n");
        }
        tagInfo.append("\n");
        
        // NDEF 메시지 파싱
        if (rawMessages != null && rawMessages.length > 0) {
            NdefMessage[] messages = new NdefMessage[rawMessages.length];
            for (int i = 0; i < rawMessages.length; i++) {
                messages[i] = (NdefMessage) rawMessages[i];
            }
            
            tagInfo.append("📝 저장된 데이터:\n\n");
            
            for (NdefMessage message : messages) {
                NdefRecord[] records = message.getRecords();
                for (NdefRecord record : records) {
                    String payload = parseNdefRecord(record);
                    if (payload != null && !payload.isEmpty()) {
                        tagInfo.append(payload).append("\n");
                    }
                }
            }
        } else {
            tagInfo.append("📭 저장된 데이터가 없습니다\n");
        }
        
        tvTagInfo.setText(tagInfo.toString());
        tvStatus.setText("태그 읽기 완료! ✅");
        
        Toast.makeText(this, "NFC 태그를 성공적으로 읽었어요!", 
            Toast.LENGTH_SHORT).show();
    }
    
    private String parseNdefRecord(NdefRecord record) {
        short tnf = record.getTnf();
        byte[] payload = record.getPayload();
        
        if (tnf == NdefRecord.TNF_WELL_KNOWN) {
            byte[] type = record.getType();
            
            if (java.util.Arrays.equals(type, NdefRecord.RTD_TEXT)) {
                // 텍스트 레코드 파싱
                try {
                    // 첫 바이트는 언어 코드 길이
                    int languageCodeLength = payload[0] & 0x3F;
                    // 실제 텍스트 추출
                    String text = new String(payload, 
                        languageCodeLength + 1, 
                        payload.length - languageCodeLength - 1, 
                        Charset.forName("UTF-8"));
                    return text;
                } catch (Exception e) {
                    return "텍스트 파싱 실패";
                }
            } else if (java.util.Arrays.equals(type, NdefRecord.RTD_URI)) {
                // URI 레코드 파싱
                return parseUriRecord(payload);
            }
        }
        
        return "알 수 없는 데이터 형식";
    }
    
    private String parseUriRecord(byte[] payload) {
        // URI 식별자 프리픽스
        String[] uriPrefixes = {
            "", "http://www.", "https://www.", "http://", "https://",
            "tel:", "mailto:", "ftp://anonymous:anonymous@", "ftp://ftp.",
            "ftps://", "sftp://", "smb://", "nfs://", "ftp://", "dav://",
            "news:", "telnet://", "imap:", "rtsp://", "urn:", "pop:",
            "sip:", "sips:", "tftp:", "btspp://", "btl2cap://", "btgoep://",
            "tcpobex://", "irdaobex://", "file://", "urn:epc:id:",
            "urn:epc:tag:", "urn:epc:pat:", "urn:epc:raw:", "urn:epc:",
            "urn:nfc:"
        };
        
        byte prefixIndex = payload[0];
        String prefix = "";
        
        if (prefixIndex >= 0 && prefixIndex < uriPrefixes.length) {
            prefix = uriPrefixes[prefixIndex];
        }
        
        String uri = new String(payload, 1, payload.length - 1, 
            Charset.forName("UTF-8"));
        
        return prefix + uri;
    }
    
    private String bytesToHex(byte[] bytes) {
        StringBuilder sb = new StringBuilder();
        for (byte b : bytes) {
            sb.append(String.format("%02X", b));
        }
        return sb.toString();
    }
}

와... 코드가 좀 길죠?ㅋㅋㅋ 근데 하나하나 뜯어보면 별거 없어요!

핵심 포인트만 정리해볼게요:

이제 태그에 데이터를 쓰는 기능을 추가해볼게요! 위 MainActivity 클래스에 다음 메서드를 추가하면 돼요.

    private void writeToTag(Tag tag, String data) {
        try {
            // NDEF 레코드 생성
            NdefRecord record = createTextRecord(data);
            NdefMessage message = new NdefMessage(new NdefRecord[] { record });
            
            // Ndef 기술 가져오기
            Ndef ndef = Ndef.get(tag);
            
            if (ndef != null) {
                // 이미 포맷된 태그
                ndef.connect();
                
                // 쓰기 가능 여부 확인
                if (!ndef.isWritable()) {
                    tvStatus.setText("이 태그는 읽기 전용이에요 🔒");
                    Toast.makeText(this, "쓰기 불가능한 태그입니다", 
                        Toast.LENGTH_SHORT).show();
                    ndef.close();
                    return;
                }
                
                // 용량 확인
                int size = message.toByteArray().length;
                int maxSize = ndef.getMaxSize();
                
                if (size > maxSize) {
                    tvStatus.setText("데이터가 너무 커요! 😅");
                    Toast.makeText(this, 
                        String.format("최대 %d바이트까지 가능해요", maxSize), 
                        Toast.LENGTH_SHORT).show();
                    ndef.close();
                    return;
                }
                
                // 데이터 쓰기
                ndef.writeNdefMessage(message);
                ndef.close();
                
                tvStatus.setText("쓰기 완료! ✅");
                tvTagInfo.setText("✍️ 쓴 내용:\n\n" + data);
                Toast.makeText(this, "NFC 태그에 성공적으로 썼어요!", 
                    Toast.LENGTH_SHORT).show();
                
                writeMode = false;
                etWriteData.setText("");
                
            } else {
                // 포맷되지 않은 태그
                NdefFormatable format = NdefFormatable.get(tag);
                
                if (format != null) {
                    try {
                        format.connect();
                        format.format(message);
                        format.close();
                        
                        tvStatus.setText("포맷 후 쓰기 완료! ✅");
                        tvTagInfo.setText("✍️ 쓴 내용:\n\n" + data);
                        Toast.makeText(this, 
                            "태그를 포맷하고 데이터를 썼어요!", 
                            Toast.LENGTH_SHORT).show();
                        
                        writeMode = false;
                        etWriteData.setText("");
                        
                    } catch (IOException e) {
                        tvStatus.setText("포맷 실패 😢");
                        Toast.makeText(this, "태그 포맷에 실패했어요", 
                            Toast.LENGTH_SHORT).show();
                    }
                } else {
                    tvStatus.setText("지원하지 않는 태그예요 ❌");
                    Toast.makeText(this, "이 태그는 쓸 수 없어요", 
                        Toast.LENGTH_SHORT).show();
                }
            }
            
        } catch (Exception e) {
            tvStatus.setText("쓰기 실패 😢");
            Toast.makeText(this, "오류: " + e.getMessage(), 
                Toast.LENGTH_SHORT).show();
            e.printStackTrace();
        }
    }
    
    private NdefRecord createTextRecord(String text) {
        // 언어 코드
        String lang = "en";
        byte[] langBytes = lang.getBytes(Charset.forName("US-ASCII"));
        
        // 텍스트 바이트
        byte[] textBytes = text.getBytes(Charset.forName("UTF-8"));
        
        // 페이로드 생성
        int langLength = langBytes.length;
        int textLength = textBytes.length;
        byte[] payload = new byte[1 + langLength + textLength];
        
        // 첫 바이트: 언어 코드 길이
        payload[0] = (byte) langLength;
        
        // 언어 코드 복사
        System.arraycopy(langBytes, 0, payload, 1, langLength);
        
        // 텍스트 복사
        System.arraycopy(textBytes, 0, payload, 1 + langLength, textLength);
        
        // NDEF 레코드 생성
        return new NdefRecord(
            NdefRecord.TNF_WELL_KNOWN,
            NdefRecord.RTD_TEXT,
            new byte[0],
            payload
        );
    }
    
    // URI 레코드 생성 메서드 (추가 기능)
    private NdefRecord createUriRecord(String uri) {
        byte[] uriBytes = uri.getBytes(Charset.forName("UTF-8"));
        byte[] payload = new byte[uriBytes.length + 1];
        
        // 프리픽스 없음
        payload[0] = 0x00;
        System.arraycopy(uriBytes, 0, payload, 1, uriBytes.length);
        
        return new NdefRecord(
            NdefRecord.TNF_WELL_KNOWN,
            NdefRecord.RTD_URI,
            new byte[0],
            payload
        );
    }

쓰기 기능의 핵심 로직을 설명해볼게요!

1. NDEF 레코드 생성
createTextRecord() 메서드로 텍스트를 NDEF 형식으로 변환해요. 언어 코드와 실제 텍스트를 조합해서 페이로드를 만드는 거죠.

2. 태그 상태 확인
태그가 이미 포맷되어 있는지, 쓰기 가능한지, 용량은 충분한지 체크해요. 이거 안 하면 에러 나기 쉬워요ㅠㅠ

3. 데이터 쓰기
ndef.writeNdefMessage()로 실제 데이터를 태그에 써요. 포맷되지 않은 태그는 format.format()으로 포맷하면서 동시에 데이터를 쓸 수 있어요!

4. 에러 처리
각 단계마다 적절한 에러 메시지를 표시해서 사용자가 뭐가 문제인지 알 수 있게 해줘요 💬

NFC 앱 개발할 때 보안도 신경 써야 해요! 특히 민감한 정보를 다룬다면 더더욱이요 🔒

몇 가지 중요한 보안 팁을 알려드릴게요:

간단한 암호화 예제도 보여드릴게요:

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import android.util.Base64;

public class NFCEncryption {
    
    private static final String ALGORITHM = "AES";
    private static final String KEY = "MySecretKey12345"; // 실제로는 안전하게 관리!
    
    // 데이터 암호화
    public static String encrypt(String data) {
        try {
            SecretKeySpec key = new SecretKeySpec(KEY.getBytes(), ALGORITHM);
            Cipher cipher = Cipher.getInstance(ALGORITHM);
            cipher.init(Cipher.ENCRYPT_MODE, key);
            
            byte[] encryptedBytes = cipher.doFinal(data.getBytes());
            return Base64.encodeToString(encryptedBytes, Base64.DEFAULT);
            
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
    
    // 데이터 복호화
    public static String decrypt(String encryptedData) {
        try {
            SecretKeySpec key = new SecretKeySpec(KEY.getBytes(), ALGORITHM);
            Cipher cipher = Cipher.getInstance(ALGORITHM);
            cipher.init(Cipher.DECRYPT_MODE, key);
            
            byte[] decodedBytes = Base64.decode(encryptedData, Base64.DEFAULT);
            byte[] decryptedBytes = cipher.doFinal(decodedBytes);
            
            return new String(decryptedBytes);
            
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
}

이렇게 암호화해서 태그에 저장하면 훨씬 안전하겠죠? 😊

이제 실제로 어떻게 활용할 수 있는지 몇 가지 예제를 보여드릴게요!

NFC 기술은 정말 다양한 분야에서 쓸 수 있거든요 ✨

NFC 태그에 연락처 정보를 저장해서 스마트 명함을 만들 수 있어요!

private NdefRecord createVCardRecord(String name, String phone, String email) {
    String vCard = "BEGIN:VCARD\n" +
                   "VERSION:3.0\n" +
                   "FN:" + name + "\n" +
                   "TEL:" + phone + "\n" +
                   "EMAIL:" + email + "\n" +
                   "END:VCARD";
    
    byte[] vCardBytes = vCard.getBytes(Charset.forName("UTF-8"));
    
    return new NdefRecord(
        NdefRecord.TNF_MIME_MEDIA,
        "text/x-vcard".getBytes(),
        new byte[0],
        vCardBytes
    );
}

// 사용 예시
NdefRecord vCardRecord = createVCardRecord(
    "홍길동", 
    "010-1234-5678", 
    "hong@example.com"
);
NdefMessage message = new NdefMessage(new NdefRecord[] { vCardRecord });
// 태그에 쓰기...

NFC 태그를 집안 곳곳에 붙여서 스마트 홈 기기를 제어할 수 있어요!

private void handleSmartHomeTag(String command) {
    switch (command) {
        case "LIGHT_ON":
            // 조명 켜기
            controlLight(true);
            Toast.makeText(this, "조명을 켰어요! 💡", Toast.LENGTH_SHORT).show();
            break;
            
        case "LIGHT_OFF":
            // 조명 끄기
            controlLight(false);
            Toast.makeText(this, "조명을 껐어요! 🌙", Toast.LENGTH_SHORT).show();
            break;
            
        case "AC_ON":
            // 에어컨 켜기
            controlAirConditioner(true);
            Toast.makeText(this, "에어컨을 켰어요! ❄️", Toast.LENGTH_SHORT).show();
            break;
            
        case "GOODNIGHT":
            // 취침 모드
            controlLight(false);
            controlAirConditioner(true);
            setAlarm();
            Toast.makeText(this, "굿나잇 모드 활성화! 😴", Toast.LENGTH_SHORT).show();
            break;
    }
}

private void controlLight(boolean on) {
    // 실제로는 스마트 홈 API 호출
    // 예: SmartHomeAPI.setLight(on);
}

private void controlAirConditioner(boolean on) {
    // 에어컨 제어 로직
}

회사나 학교 출입증으로도 활용할 수 있어요!

private void handleAccessControl(Tag tag) {
    String tagId = bytesToHex(tag.getId());
    
    // 서버에 인증 요청
    checkAccessPermission(tagId, new AccessCallback() {
        @Override
        public void onSuccess(UserInfo userInfo) {
            // 출입 허가
            tvStatus.setText("환영합니다, " + userInfo.getName() + "님! 🎉");
            openDoor();
            logAccess(userInfo, true);
        }
        
        @Override
        public void onFailure(String reason) {
            // 출입 거부
            tvStatus.setText("출입이 거부되었습니다 ❌");
            Toast.makeText(MainActivity.this, 
                "사유: " + reason, Toast.LENGTH_LONG).show();
            logAccess(null, false);
        }
    });
}

private void checkAccessPermission(String tagId, AccessCallback callback) {
    // 실제로는 서버 API 호출
    // 예시 코드
    new Thread(() -> {
        try {
            // API 호출 로직
            // Response response = api.checkAccess(tagId);
            
            // 임시 예제
            UserInfo user = new UserInfo("홍길동", "개발팀");
            runOnUiThread(() -> callback.onSuccess(user));
            
        } catch (Exception e) {
            runOnUiThread(() -> callback.onFailure(e.getMessage()));
        }
    }).start();
}

interface AccessCallback {
    void onSuccess(UserInfo userInfo);
    void onFailure(String reason);
}

class UserInfo {
    private String name;
    private String department;
    
    public UserInfo(String name, String department) {
        this.name = name;
        this.department = department;
    }
    
    public String getName() { return name; }
    public String getDepartment() { return department; }
}

이런 식으로 다양하게 응용할 수 있어요! 아이디어만 있다면 무궁무진하죠 🚀

NFC 개발하다 보면 자주 만나는 에러들이 있어요. 미리 알아두면 삽질 안 해도 되죠ㅋㅋㅋ

에러 처리 강화 버전 코드도 보여드릴게요:

private void writeToTagWithRetry(Tag tag, String data, int retryCount) {
    int attempts = 0;
    boolean success = false;
    
    while (attempts < retryCount && !success) {
        try {
            attempts++;
            
            NdefRecord record = createTextRecord(data);
            NdefMessage message = new NdefMessage(new NdefRecord[] { record });
            
            Ndef ndef = Ndef.get(tag);
            
            if (ndef != null) {
                ndef.connect();
                
                if (!ndef.isWritable()) {
                    throw new IOException("Tag is read-only");
                }
                
                ndef.writeNdefMessage(message);
                ndef.close();
                success = true;
                
                tvStatus.setText("쓰기 완료! ✅");
                Toast.makeText(this, "성공!", Toast.LENGTH_SHORT).show();
                
            } else {
                throw new IOException("Tag is not NDEF formatted");
            }
            
        } catch (IOException e) {
            if (attempts >= retryCount) {
                tvStatus.setText("쓰기 실패 😢");
                Toast.makeText(this, 
                    String.format("실패 (%d번 시도): %s", attempts, e.getMessage()), 
                    Toast.LENGTH_LONG).show();
            } else {
                // 재시도
                try {
                    Thread.sleep(500); // 0.5초 대기
                } catch (InterruptedException ie) {
                    ie.printStackTrace();
                }
            }
        }
    }
}

이렇게 재시도 로직을 추가하면 훨씬 안정적으로 동작해요! 💪

NFC 앱을 더 빠르고 효율적으로 만드는 방법들이에요!

AsyncTask 예제도 보여드릴게요:

private class WriteNFCTask extends AsyncTask<Void, Void, Boolean> {
    
    private Tag tag;
    private String data;
    private String errorMessage;
    
    public WriteNFCTask(Tag tag, String data) {
        this.tag = tag;
        this.data = data;
    }
    
    @Override
    protected void onPreExecute() {
        super.onPreExecute();
        // UI 업데이트 (로딩 표시)
        tvStatus.setText("쓰는 중... ⏳");
        btnWrite.setEnabled(false);
    }
    
    @Override
    protected Boolean doInBackground(Void... voids) {
        try {
            NdefRecord record = createTextRecord(data);
            NdefMessage message = new NdefMessage(new NdefRecord[] { record });
            
            Ndef ndef = Ndef.get(tag);
            if (ndef != null) {
                ndef.connect();
                ndef.writeNdefMessage(message);
                ndef.close();
                return true;
            }
            
            errorMessage = "NDEF not supported";
            return false;
            
        } catch (Exception e) {
            errorMessage = e.getMessage();
            return false;
        }
    }
    
    @Override
    protected void onPostExecute(Boolean success) {
        super.onPostExecute(success);
        
        btnWrite.setEnabled(true);
        
        if (success) {
            tvStatus.setText("쓰기 완료! ✅");
            Toast.makeText(MainActivity.this, 
                "성공적으로 썼어요!", Toast.LENGTH_SHORT).show();
        } else {
            tvStatus.setText("쓰기 실패 😢");
            Toast.makeText(MainActivity.this, 
                "오류: " + errorMessage, Toast.LENGTH_SHORT).show();
        }
    }
}

// 사용
new WriteNFCTask(tag, dataToWrite).execute();

요즘은 Kotlin Coroutine을 더 많이 쓰긴 하는데, AsyncTask도 여전히 유용해요!

기능도 중요하지만 사용자 경험도 엄청 중요하죠! 몇 가지 UI/UX 팁을 드릴게요 😊

진동 피드백 추가하는 코드예요:

import android.os.Vibrator;
import android.content.Context;

private void provideHapticFeedback() {
    Vibrator vibrator = (Vibrator) getSystemService(Context.VIBRATOR_SERVICE);
    if (vibrator != null && vibrator.hasVibrator()) {
        // 짧은 진동 (100ms)
        vibrator.vibrate(100);
    }
}

// NFC 태그 감지 시 호출
private void handleIntent(Intent intent) {
    String action = intent.getAction();
    
    if (NfcAdapter.ACTION_NDEF_DISCOVERED.equals(action) ||
        NfcAdapter.ACTION_TAG_DISCOVERED.equals(action)) {
        
        // 진동 피드백
        provideHapticFeedback();
        
        // 소리 피드백 (선택사항)
        playBeepSound();
        
        Tag tag = intent.getParcelableExtra(NfcAdapter.EXTRA_TAG);
        // ... 나머지 처리
    }
}

private void playBeepSound() {
    // ToneGenerator로 비프음 재생
    ToneGenerator toneGen = new ToneGenerator(AudioManager.STREAM_MUSIC, 100);
    toneGen.startTone(ToneGenerator.TONE_PROP_BEEP, 150);
}

여러분이 이 글을 보고 NFC 개발 실력을 쌓았다면, 재능넷에서 다른 사람들과 재능을 공유해보는 건 어떨까요?

재능넷(https://www.jaenung.net)은 다양한 IT 개발 재능을 거래할 수 있는 플랫폼이에요! 💼

예를 들어:
✅ "NFC 앱 개발 컨설팅" 재능 등록
✅ "스마트 명함 앱 제작" 서비스 제공
✅ "출입 관리 시스템 구축" 프로젝트 수주
✅ "NFC 프로그래밍 과외" 강의

이런 식으로 여러분의 전문성을 활용할 수 있어요! 실제로 NFC 기술은 수요가 꽤 있는 분야거든요 😎

또한 재능넷의 지식인의 숲 같은 곳에서 여러분의 노하우를 공유하면서 다른 개발자들과 소통할 수도 있고요!

더 깊이 공부하고 싶은 분들을 위한 리소스들이에요!

와... 여기까지 정말 긴 여정이었네요!ㅋㅋㅋ 고생 많으셨어요 👏

오늘 다룬 내용을 정리해볼게요:

✅ NFC 기본 개념과 동작 원리
✅ 안드로이드 NFC 개발 환경 세팅
✅ NFC 태그 읽기 기능 구현
✅ NFC 태그 쓰기 기능 구현
✅ 보안 고려사항과 암호화
✅ 실전 활용 예제들
✅ 에러 처리와 성능 최적화
✅ UI/UX 개선 방법

이 정도면 기본적인 NFC 앱은 충분히 만들 수 있을 거예요! 💪

물론 처음엔 어려울 수 있어요. 저도 처음 NFC 개발할 때 태그가 안 읽혀서 몇 시간 동안 삽질했던 기억이 나네요ㅋㅋㅋ

하지만 포기하지 말고 계속 시도해보세요! 실제 기기로 테스트하면서 하나하나 익혀가다 보면 어느새 전문가가 되어 있을 거예요 😊

핵심은 실습입니다! 이론만 보지 말고 직접 코드를 작성하고, 태그를 읽고 쓰면서 경험을 쌓으세요.

그리고 막히는 부분이 있으면 주저하지 말고 커뮤니티에 질문하세요. 개발자들은 서로 돕는 문화가 있으니까요! 🤝

여러분의 NFC 앱 개발 여정에 이 글이 도움이 되었으면 좋겠어요. 멋진 앱 만들어서 재능넷에도 공유해주시고요!

그럼 오늘도 즐거운 코딩 되세요! 화이팅! 🎉✨