Jeffery World!!! "Sharing life": AsyncTask<...>로 구현한 블루투스 통신 프로그램

안드로이드용 스마트폰에서 실행되는 블루투스 통신 프로그램

AsyncTask<...>로 Thread를 대치한 프로그램

package hbsong.robot.dongyang;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.UUID;

import android.app.Activity;
import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothServerSocket;
import android.bluetooth.BluetoothSocket;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.os.AsyncTask;
import android.os.Bundle;
import android.os.Handler;
import android.util.Log;
import android.view.KeyEvent;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.View.OnKeyListener;
import android.widget.AdapterView;
import android.widget.AdapterView.OnItemClickListener;
import android.widget.ArrayAdapter;
import android.widget.Button;
import android.widget.EditText;
import android.widget.ListView;
import android.widget.TextView;

public class ExpBluetooth001Activity extends Activity {
    /** Called when the activity is first created. */
 
 private static final boolean D = true;
 private static final String TAG = "SONG : ExpBluetooth001";
 
 
  // Intent request codes
    private static final int REQUEST_CONNECT_DEVICE_SECURE = 10;
    private static final int REQUEST_CONNECT_DEVICE_INSECURE = 20;
    private static final int REQUEST_ENABLE_BT = 30;
    
    private static final int DISCOVERY_REQUEST = 4;
    
 
    private BluetoothAdapter bluetooth;
    private ArrayAdapter<string> mPairedDevicesArrayAdapter;
    private BluetoothSocket socket;
    private UUID uuid = UUID.fromString("00001101-0000-1000-8000-00805F9B34FB");
    
    private ArrayAdapter<bluetoothdevice> aa;
    private ArrayList<bluetoothdevice> foundDevices = new ArrayList<bluetoothdevice> ();
    private ListView list;
    
   
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        
     // Get the Bluetooth Adapter
        if(D) Log.e(TAG, "---> Get the Bluetooth Adapter ");
        bluetooth = BluetoothAdapter.getDefaultAdapter();
     if (bluetooth == null) {
      if(D) Log.e(TAG, "---> Bluetooth is not supported on the device");
     }
     if (!bluetooth.isEnabled()) {
         Intent enableBtIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
         startActivityForResult(enableBtIntent, REQUEST_ENABLE_BT);
     } else {
      if(D) Log.e(TAG, "---> Bluetooth is already enabled");
     }
      
     setupListView(); 
     setupSearchButton();
     setupListenButton();
    }
    
    private void setupListView() { 
     
     if(D) Log.e(TAG, "---> setting up ListView");
           
  
     aa = new ArrayAdapter<bluetoothdevice>(this, android.R.layout.simple_list_item_1, foundDevices);
     list = (ListView)findViewById(R.id.list_discovered);
     list.setAdapter(aa);
     
     list.setOnItemClickListener(new OnItemClickListener() {
      public void onItemClick(AdapterView<?> arg0, View view, int index, long arg3) {
       AsyncTask<Integer, Void, Void> connectTask = new AsyncTask<Integer, Void, Void>() {
      
        @Override
        protected Void doInBackground(Integer ... params) {
         try {
          if(D) Log.e(TAG, "---> doInBackground(Integer ... params) ");
          BluetoothDevice device = foundDevices.get(params[0]);
          if(D) Log.e(TAG, device.toString());
          
          bluetooth.cancelDiscovery();
          
          socket = device.createRfcommSocketToServiceRecord(uuid);
          socket.connect();
         } catch (IOException e) {
          Log.d("BLUETOOTH_CLIENT", e.getMessage());
         }
         return null;
        }
     
        @Override
        protected void onPostExecute(Void result) {
         if(D) Log.e(TAG, " onPostExecute(Void result ---> unregisterReceiver(discoveryResult) ");
         unregisterReceiver(discoveryResult);
         switchUI();
        }
       };
       
       connectTask.execute(index);
      } 
     });
    }

private Handler handler = new Handler();
    private void switchUI() {
     if(D) Log.e(TAG, "---> switchUI() ");
     final TextView messageText = (TextView)findViewById(R.id.text_messages);
     final EditText textEntry = (EditText)findViewById(R.id.text_message);
     messageText.setVisibility(View.VISIBLE);
     list.setVisibility(View.GONE);
     textEntry.setEnabled(true);
     textEntry.setOnKeyListener(new OnKeyListener() {
      public boolean onKey(View view, int keyCode, KeyEvent keyEvent) {
       if ((keyEvent.getAction() == KeyEvent.ACTION_DOWN) &&
         (keyCode == KeyEvent.KEYCODE_ENTER)) {
          sendMessage(socket, textEntry.getText().toString());
          textEntry.setText("");
          return true;
       }
       return false;
      }
     });
     BluetoothSocketListener bsl = new BluetoothSocketListener(socket, handler, messageText);
     Thread messageListener = new Thread(bsl);
     messageListener.start();
    }

private class MessagePoster implements Runnable {
     private TextView textView;
     private String message;
     public MessagePoster(TextView textView, String message) {
      this.textView = textView;
      this.message = message;
     }
     public void run() {
      textView.setText(message);
     }
    }

private class BluetoothSocketListener implements Runnable {
     private BluetoothSocket socket;
     private TextView textView;
     private Handler handler;
     public BluetoothSocketListener(BluetoothSocket socket, Handler handler, TextView textView) {
      if(D) Log.e(TAG, "BluetoothSocketListener  " );
      this.socket = socket;
      this.textView = textView;
      this.handler = handler;
     }
     
     public void run() {
      int bufferSize = 1024;
      byte[] buffer = new byte[bufferSize];
      
      if(D) Log.e(TAG, "BluetoothSocketListener ---> run() " );
      try {
       InputStream instream = socket.getInputStream();
       int bytesRead = -1;
       String message = "";
       
     
     while (true) {
        message = "";
        bytesRead = instream.read(buffer);
        if(D) Log.e(TAG, "BluetoothSocketListener --->  run() " + message );
        if (bytesRead != -1) {
         while ((bytesRead==bufferSize)&&(buffer[bufferSize-1] != 0)) {
          message = message + new String(buffer, 0, bytesRead);
          if(D) Log.e(TAG, "BluetoothSocketListener --->  run() " + message );
          bytesRead = instream.read(buffer);
         }
        message = message + new String(buffer, 0, bytesRead-1);
        handler.post(new MessagePoster(textView, message));
        socket.getInputStream();  // exit loop for false
        }
       } 
    
      } catch (IOException e) {
       Log.d("BLUETOOTH_COMMS", e.getMessage());
      }
     }
    }

private void sendMessage(BluetoothSocket socket, String msg) {
     OutputStream outStream;
     try {
      if(D) Log.e(TAG, "sendMessage ----> " + msg);
      outStream = socket.getOutputStream();
      byte[] byteString = (msg).getBytes();
      outStream.write(byteString);
     } catch (IOException e) {
      Log.d("BLUETOOTH_COMMS", e.getMessage());
     }
    }
    
    
    private void setupListenButton() {
     
      if(D) Log.e(TAG, "---> setupListenButton() ");
      
     Button listenButton = (Button)findViewById(R.id.button_listen);
     listenButton.setOnClickListener(new OnClickListener() {
       public void onClick(View view) {
        
        if(D) Log.e(TAG, "---> setupListenButton():onClick(View view) ");
        
        Intent disc;
        disc = new Intent(BluetoothAdapter.ACTION_REQUEST_DISCOVERABLE);
        startActivityForResult(disc, DISCOVERY_REQUEST);
       }
     });
    }
    
    private void setupSearchButton() {
     
     if(D) Log.e(TAG, "---> setupSearchButton() ");
     
     Button searchButton = (Button)findViewById(R.id.button_search);
     searchButton.setOnClickListener(new OnClickListener() {
      public void onClick(View view) {
       if(D) Log.e(TAG, "---> setupSearchButton():onClick(View view) ");
      
       registerReceiver(discoveryResult, new IntentFilter(BluetoothDevice.ACTION_FOUND));
       if (!bluetooth.isDiscovering()) {
        if(D) Log.e(TAG, "---> setupSearchButton():bluetooth.startDiscovery() ");
        foundDevices.clear();
        bluetooth.startDiscovery();
       }
       
      }
     });
    }
    
    
    BroadcastReceiver discoveryResult = new BroadcastReceiver() {
     public void onReceive(Context context, Intent intent) {
      
     
      if(D) Log.e(TAG, "---> BroadcastReceiver() ");
      
      BluetoothDevice remoteDevice;
      remoteDevice = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
     
     
      if (bluetooth.getBondedDevices().contains(remoteDevice)) {
       if(D) Log.e(TAG, "---> BroadcastReceiver() : foundDevices.add ");
       foundDevices.add(remoteDevice);
       aa.notifyDataSetChanged();
       
      }
     }
    };
    
 
    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
   
       
      switch (requestCode) {
      case REQUEST_ENABLE_BT:
           if(D) Log.e(TAG, "---> REQUEST_ENABLE_BT ");
       break;
              case DISCOVERY_REQUEST:
               if(D) Log.e(TAG, "---> DISCOVERY_REQUEST ");
              
               boolean isDiscoverable = resultCode > 0;
               if (isDiscoverable) {
             String name = "bluetoothserver";
             try {
              final BluetoothServerSocket btserver =
                bluetooth.listenUsingRfcommWithServiceRecord(name, uuid);
              AsyncTask<Integer, Void, BluetoothSocket> acceptThread =
                new AsyncTask<Integer, Void, BluetoothSocket>() {
                 @Override
                 protected BluetoothSocket doInBackground(Integer...params) {
                  try {
                   socket = btserver.accept(params[0]*1000);
                   return socket;
                  } catch (IOException e) {
                   Log.d("BLUETOOTH", e.getMessage());
                  }
                  return null;
                 }
          
                @Override
                protected void onPostExecute(BluetoothSocket result) {
                 if (result != null)
                  switchUI();
                }
          
              };
              acceptThread.execute(resultCode);
             } catch (IOException e) {
              Log.d("BLUETOOTH", e.getMessage());
             }
               }
               break;
              }
         
     } 
    
     
    @Override
     protected void onPause() {
  // TODO Auto-generated method stub
  super.onPause(); 
     }

@Override
     protected void onDestroy() {
  // TODO Auto-generated method stub
  super.onDestroy();
  try {
   if(D) Log.e(TAG, " onDestroy() ---> socket.close() ");
    socket.close();
   } catch ( IOException e ) {
    Log.d("BLUETOOTH_CLIENT", e.getMessage());
   }
     }
 
}

Jeffery World!!! "Sharing life"

2013년 12월 18일 수요일

AsyncTask<...>로 구현한 블루투스 통신 프로그램

댓글 없음:

댓글 쓰기