I am currently writing my first Android application, and am having trouble grasping how to structure it. From my previous programming experience I was planning on using a MVC design but now I don't know if I can implement that. My program consists of several different activities which all need access to a single Bluetooth connection. I currently have two activities written along with another class (AndroidBluetooth is my main page, DeviceList is a pop up which lets you connect to a device, and BluetoothModel is where I have been storing all of my Bluetooth information). Is there some way to initialize objects at the start of a program so that every activity can access them? My code is attached below; I know that there is a lot of overlapping methods, I need to clean it up a bit.AndroidBluetooth:// Member fields//private final Handler mHandler;private ConnectThread mConnectThread;private ConnectedThread mConnectedThread;private int mState;//private EmulatorView mEmulatorView;// Constants that indicate the current connection statepublic static final int STATE_NONE = 0;       // we're doing nothingpublic static final int STATE_LISTEN = 1;     // now listening for incoming connectionspublic static final int STATE_CONNECTING = 2; // now initiating an outgoing connectionpublic static final int STATE_CONNECTED = 3;  // now connected to a remote devicepublic int currentState;public boolean customTitleSupported;public BluetoothModel btModel;@Overridepublic void onCreate(Bundle savedInstanceState) {    super.onCreate(savedInstanceState);    currentState = 0;    customTitleSupported = requestWindowFeature( Window.FEATURE_CUSTOM_TITLE );    // Set up window View    setContentView(R.layout.main);    stateBluetooth = new TextView(this);    myBtAdapter = null;    startBluetooth();    checkBlueToothState();    customTitleBar( getText( R.string.app_name).toString(), stateBluetooth.getText().toString() );}public void customTitleBar( String left, String right ) {    if( right.length() > 30 ) right = right.substring( 0, 20 );    if( customTitleSupported ) {        getWindow().setFeatureInt( Window.FEATURE_CUSTOM_TITLE, R.layout.customlayoutbar );        TextView titleTvLeft = (TextView) findViewById( R.id.titleTvLeft );        TextView titleTvRight = (TextView) findViewById( R.id.titleTvRight );        titleTvLeft.setText( left );        titleTvRight.setText( right );    }}public boolean onCreateOptionsMenu( Menu menu ) {    MenuInflater inflater = getMenuInflater();    inflater.inflate( R.menu.option_menu, menu );    return true;}public boolean onOptionsItemSelected( MenuItem item ) {    switch( item.getItemId() ) {    case R.id.connect:        startActivityForResult( new Intent( this, DeviceList.class ), REQUEST_CONNECT_DEVICE  );        return true;    case R.id.preferences:        return true;    default:        return super.onContextItemSelected( item );    }}private void checkBlueToothState() {    if( myBtAdapter == null ) {        stateBluetooth.setText(Bluetooth NOT supported );    } else {        if( myBtAdapter.isEnabled() ) {            if( myBtAdapter.isDiscovering() ) {                stateBluetooth.setText( Bluetooth is currently  +                        in device discovery process. );            } else {                stateBluetooth.setText( Bluetooth is Enabled. );            }        } else {            stateBluetooth.setText( Bluetooth is NOT enabled );            Intent enableBtIntent = new Intent( BluetoothAdapter.ACTION_REQUEST_ENABLE );            startActivityForResult( enableBtIntent, REQUEST_ENABLE_BT );        }    }}public void onActivityResult(int requestCode, int resultCode, Intent data) {    if(D) Log.d( TAG, onActivityResult  + resultCode);    switch (requestCode) {    case REQUEST_CONNECT_DEVICE:        // When DeviceListActivity returns with a device to connect        if (resultCode == Activity.RESULT_OK) {            // Get the device MAC address            String address = data.getExtras()                                 .getString(DeviceList.EXTRA_DEVICE_ADDRESS);            // Get the BLuetoothDevice object            BluetoothDevice device = myBtAdapter.getRemoteDevice(address);            // Attempt to connect to the device            btModel.connect(device);                        }        break;    case REQUEST_ENABLE_BT:        // When the request to enable Bluetooth returns        checkBlueToothState();    }}//In SDK15 (4.0.3) this method is now public as//Bluetooth.fetchUuisWithSdp() and BluetoothDevice.getUuids()public ParcelUuid[] servicesFromDevice(BluetoothDevice device) {    try {        Class cl = Class.forName(android.bluetooth.BluetoothDevice);        Class[] par = {};        Method method = cl.getMethod(getUuids, par);        Object[] args = {};        ParcelUuid[] retval = (ParcelUuid[]) method.invoke(device, args);        return retval;    } catch (Exception e) {        e.printStackTrace();        return null;    }}private final BroadcastReceiver ActionFoundReceiver = new BroadcastReceiver() {    public void onReceive( Context context, Intent intent ) {        String action = intent.getAction();        if( BluetoothDevice.ACTION_FOUND.equals( action ) ) {            BluetoothDevice btDevice = intent.getParcelableExtra( BluetoothDevice.EXTRA_DEVICE );            btDevicesFound.add( btDevice );            btArrayAdapter.add( btDevice.getName() + \n + btDevice.getAddress() );            btArrayAdapter.notifyDataSetChanged();        }               }};public static void startBluetooth(){    try {        myBtAdapter = BluetoothAdapter.getDefaultAdapter();        myBtAdapter.enable();    } catch ( NullPointerException ex ) {        Log.e( Bluetooth, Device not available );    }}public static void stopBluetooth() {    myBtAdapter.disable();}}DeviceList:// Return Intent extrapublic static String EXTRA_DEVICE_ADDRESS = device_address;// Member fieldsprivate BluetoothAdapter mBtAdapter;private ArrayAdapter<String> mPairedDevicesArrayAdapter;private ArrayAdapter<String> mNewDevicesArrayAdapter;@Overrideprotected void onCreate(Bundle savedInstanceState) {    super.onCreate(savedInstanceState);    // Setup the window    requestWindowFeature(Window.FEATURE_INDETERMINATE_PROGRESS);    setContentView(R.layout.device_list);    // Set result CANCELED incase the user backs out    setResult(Activity.RESULT_CANCELED);    // Initialize the button to perform device discovery    Button scanButton = (Button) findViewById(R.id.button_scan);    scanButton.setOnClickListener(new OnClickListener() {        public void onClick(View v) {            doDiscovery();            v.setVisibility(View.GONE);        }    });    // Initialize array adapters. One for already paired devices and    // one for newly discovered devices    mPairedDevicesArrayAdapter = new ArrayAdapter<String>(this, R.layout.device_name);    mNewDevicesArrayAdapter = new ArrayAdapter<String>(this, R.layout.device_name);    // Find and set up the ListView for paired devices    ListView pairedListView = (ListView) findViewById(R.id.paired_devices);    pairedListView.setAdapter(mPairedDevicesArrayAdapter);    pairedListView.setOnItemClickListener(mDeviceClickListener);    // Find and set up the ListView for newly discovered devices    ListView newDevicesListView = (ListView) findViewById(R.id.new_devices);    newDevicesListView.setAdapter(mNewDevicesArrayAdapter);    newDevicesListView.setOnItemClickListener(mDeviceClickListener);    // Register for broadcasts when a device is discovered    IntentFilter filter = new IntentFilter(BluetoothDevice.ACTION_FOUND);    this.registerReceiver(mReceiver, filter);    // Register for broadcasts when discovery has finished    filter = new IntentFilter(BluetoothAdapter.ACTION_DISCOVERY_FINISHED);    this.registerReceiver(mReceiver, filter);    // Get the local Bluetooth adapter    mBtAdapter = BluetoothAdapter.getDefaultAdapter();    // Get a set of currently paired devices    Set<BluetoothDevice> pairedDevices = mBtAdapter.getBondedDevices();    // If there are paired devices, add each one to the ArrayAdapter    if (pairedDevices.size() > 0) {        findViewById(R.id.title_paired_devices).setVisibility(View.VISIBLE);        for (BluetoothDevice device : pairedDevices) {            mPairedDevicesArrayAdapter.add(device.getName() + \n + device.getAddress());        }    } else {        String noDevices = getResources().getText(R.string.none_paired).toString();        mPairedDevicesArrayAdapter.add(noDevices);    }}@Overrideprotected void onDestroy() {    super.onDestroy();    // Make sure we're not doing discovery anymore    if (mBtAdapter != null) {        mBtAdapter.cancelDiscovery();    }    // Unregister broadcast listeners    this.unregisterReceiver(mReceiver);}/** * Start device discover with the BluetoothAdapter */private void doDiscovery() {    if (D) Log.d(TAG, doDiscovery());    // Indicate scanning in the title    setProgressBarIndeterminateVisibility(true);    setTitle(R.string.scanning);    // Turn on sub-title for new devices    findViewById(R.id.title_new_devices).setVisibility(View.VISIBLE);    // If we're already discovering, stop it    if (mBtAdapter.isDiscovering()) {        mBtAdapter.cancelDiscovery();    }    // Request discover from BluetoothAdapter    mBtAdapter.startDiscovery();}// The on-click listener for all devices in the ListViewsprivate OnItemClickListener mDeviceClickListener = new OnItemClickListener() {    public void onItemClick(AdapterView<?> av, View v, int arg2, long arg3) {        // Cancel discovery because it's costly and we're about to connect        mBtAdapter.cancelDiscovery();        // Get the device MAC address, which is the last 17 chars in the View        String info = ((TextView) v).getText().toString();        String address = info.substring(info.length() - 17);        // Create the result Intent and include the MAC address        Intent intent = new Intent();        intent.putExtra(EXTRA_DEVICE_ADDRESS, address);        // Set result and finish this Activity        setResult(Activity.RESULT_OK, intent);        finish();    }};// The BroadcastReceiver that listens for discovered devices and// changes the title when discovery is finishedprivate final BroadcastReceiver mReceiver = new BroadcastReceiver() {    @Override    public void onReceive(Context context, Intent intent) {        String action = intent.getAction();        // When discovery finds a device        if (BluetoothDevice.ACTION_FOUND.equals(action)) {            // Get the BluetoothDevice object from the Intent            BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);            // If it's already paired, skip it, because it's been listed already            if (device.getBondState() != BluetoothDevice.BOND_BONDED) {                mNewDevicesArrayAdapter.add(device.getName() + \n + device.getAddress());            }        // When discovery is finished, change the Activity title        } else if (BluetoothAdapter.ACTION_DISCOVERY_FINISHED.equals(action)) {            setProgressBarIndeterminateVisibility(false);            setTitle(R.string.select_device);            if (mNewDevicesArrayAdapter.getCount() == 0) {                String noDevices = getResources().getText(R.string.none_found).toString();                mNewDevicesArrayAdapter.add(noDevices);            }        }    }};}BluetoothModel:public class BluetoothModel {    // Debugging    private static final String TAG = BluetoothModel;    private static final boolean D = true;    // Member fields    private final BluetoothAdapter myAdapter;    private final Handler myHandler;    private Context myContext;    private ConnectThread myConnectThread;    private ConnectedThread myConnectedThread;    private int myState;    // Constants that indicate the current connection state    public static final int STATE_NONE = 0;    public static final int STATE_LISTEN = 1;    public static final int STATE_CONNECTING = 2;    public static final int STATE_CONNECTED = 3;    public BluetoothModel( Context context, Handler handler ) {        myContext = context;        myAdapter = BluetoothAdapter.getDefaultAdapter();        myState = STATE_NONE;        myHandler = handler;    }    /**     * Set the connection state.     *      * @param state     */    public synchronized void setState( int state ) {        if( D ) Log.d( TAG, setState()  + myState +  ->  + state );        myState = state;        myHandler.obtainMessage( AndroidBluetooth.MESSAGE_STATE_CHANGE, state, -1 ).sendToTarget();    }    /**     * Get the connection state.     *      * @return     */    public synchronized int getState() {        return myState;    }    /**     * Indicate that the connection attempt failed and notify the UI Activity.     *     */    private void connectionFailed() {        setState(STATE_NONE);        // Send a failure message back to the Activity        Message msg = myHandler.obtainMessage(AndroidBluetooth.MESSAGE_TOAST);        Bundle bundle = new Bundle();        bundle.putString(AndroidBluetooth.TOAST, Unable to connect device);        msg.setData(bundle);        myHandler.sendMessage(msg);    }    /**     * Indicate that the connection was lost and notify the UI Activity.     *     */    private void connectionLost() {        setState(STATE_NONE);        // Send a failure message back to the Activity        Message msg = myHandler.obtainMessage(AndroidBluetooth.MESSAGE_TOAST);        Bundle bundle = new Bundle();        bundle.putString(AndroidBluetooth.TOAST, Device connection was lost);        msg.setData(bundle);        myHandler.sendMessage(msg);    }    /**     * Start the chat service. Specifically start AcceptThread to begin a     * session in listening (server) mode. Called by the Activity onResume() */    public synchronized void start() {        if (D) Log.d(TAG, start);        // Cancel any thread attempting to make a connection        if (myConnectThread != null) {            myConnectThread.cancel();             myConnectThread = null;        }        // Cancel any thread currently running a connection        if (myConnectedThread != null) {            myConnectedThread.cancel();             myConnectedThread = null;        }        setState(STATE_NONE);    }    /**     * Start the ConnectThread to initiate a connection to a remote device.     * @param device  The BluetoothDevice to connect     */    public synchronized void connect(BluetoothDevice device) {        if (D) Log.d(TAG, connect to:  + device);        // Cancel any thread attempting to make a connection        if (myState == STATE_CONNECTING) {            if (myConnectThread != null) {myConnectThread.cancel(); myConnectThread = null;}        }        // Cancel any thread currently running a connection        if (myConnectedThread != null) {myConnectedThread.cancel(); myConnectedThread = null;}        // Start the thread to connect with the given device        myConnectThread = new ConnectThread(device);        myConnectThread.start();        setState(STATE_CONNECTING);    }    /**     * Start the ConnectedThread to begin managing a Bluetooth connection     * @param socket  The BluetoothSocket on which the connection was made     * @param device  The BluetoothDevice that has been connected     */    public synchronized void connected(BluetoothSocket socket, BluetoothDevice device) {        if (D) Log.d(TAG, connected);        // Cancel the thread that completed the connection        if (myConnectThread != null) {            myConnectThread.cancel();             myConnectThread = null;        }        // Cancel any thread currently running a connection        if (myConnectedThread != null) {            myConnectedThread.cancel();             myConnectedThread = null;        }        // Start the thread to manage the connection and perform transmissions        myConnectedThread = new ConnectedThread(socket);        myConnectedThread.start();        // Send the name of the connected device back to the UI Activity        Message msg = myHandler.obtainMessage(AndroidBluetooth.MESSAGE_DEVICE_NAME);        Bundle bundle = new Bundle();        bundle.putString(AndroidBluetooth.DEVICE_NAME, device.getName());        msg.setData(bundle);        myHandler.sendMessage(msg);        setState(STATE_CONNECTED);    }    /**     * Stop all threads     */    public synchronized void stop() {        if (D) Log.d(TAG, stop);        if (myConnectThread != null) {            myConnectThread.cancel();             myConnectThread = null;        }        if (myConnectedThread != null) {            myConnectedThread.cancel();             myConnectedThread = null;        }        setState(STATE_NONE);    }    /**     * Write to the ConnectedThread in an unsynchronized manner     * @param out The bytes to write     * @see ConnectedThread#write(byte[])     */    public void write(byte[] out) {        // Create temporary object        ConnectedThread r;        // Synchronize a copy of the ConnectedThread        synchronized (this) {            if (myState != STATE_CONNECTED) return;            r = myConnectedThread;        }        // Perform the write unsynchronized        r.write(out);    }    /**     * This thread runs while attempting to make an outgoing connection     * with a device. It runs straight through; the connection either     * succeeds or fails.     */    public class ConnectThread extends Thread {        private final BluetoothSocket mmSocket;        private final BluetoothDevice mmDevice;        public ConnectThread(BluetoothDevice device) {            mmDevice = device;            BluetoothSocket tmp = null;            // Get a BluetoothSocket for a connection with the            // given BluetoothDevice            try {                tmp = device.createRfcommSocketToServiceRecord(SPP_UUID);            } catch (IOException e) {                Log.e(TAG, create() failed, e);            }            mmSocket = tmp;        }        public void run() {            Log.i(TAG, BEGIN mConnectThread);            setName(ConnectThread);            // Always cancel discovery because it will slow down a connection            myAdapter.cancelDiscovery();            // Make a connection to the BluetoothSocket            try {                // This is a blocking call and will only return on a                // successful connection or an exception                mmSocket.connect();            } catch (IOException e) {                connectionFailed();                // Close the socket                try {                    mmSocket.close();                } catch (IOException e2) {                    Log.e(TAG, unable to close() socket during connection failure, e2);                }                // Start the service over to restart listening mode                //BluetoothSerialService.this.start();                return;            }            // Reset the ConnectThread because we're done            synchronized (BluetoothModel.this) {                myConnectThread = null;            }            // Start the connected thread            connected(mmSocket, mmDevice);        }        public void cancel() {            try {                mmSocket.close();            } catch (IOException e) {                Log.e(TAG, close() of connect socket failed, e);            }        }    }    /**     * This thread runs during a connection with a remote device.     * It handles all incoming and outgoing transmissions.     */    public class ConnectedThread extends Thread {        private final BluetoothSocket mmSocket;        private final InputStream mmInStream;        private final OutputStream mmOutStream;        public ConnectedThread(BluetoothSocket socket) {            Log.d(TAG, create ConnectedThread);            mmSocket = socket;            InputStream tmpIn = null;            OutputStream tmpOut = null;            // Get the BluetoothSocket input and output streams            try {                tmpIn = socket.getInputStream();                tmpOut = socket.getOutputStream();            } catch (IOException e) {                Log.e(TAG, temp sockets not created, e);            }            mmInStream = tmpIn;            mmOutStream = tmpOut;        }        public void run() {            Log.i(TAG, BEGIN mConnectedThread);            byte[] buffer = new byte[1024];            int bytes;            // Keep listening to the InputStream while connected            while (true) {                try {                    // Read from the InputStream                    bytes = mmInStream.read(buffer);                    //mEmulatorView.write(buffer, bytes);                    // Send the obtained bytes to the UI Activity                    //mHandler.obtainMessage(BlueTerm.MESSAGE_READ, bytes, -1, buffer).sendToTarget();                    String a = buffer.toString();                    a = ;                } catch (IOException e) {                    Log.e(TAG, disconnected, e);                    connectionLost();                    break;                }            }        }        /**         * Write to the connected OutStream.         * @param buffer  The bytes to write         */        public void write(byte[] buffer) {            try {                mmOutStream.write(buffer);                // Share the sent message back to the UI Activity                //mHandler.obtainMessage(BlueTerm.MESSAGE_WRITE, buffer.length, -1, buffer)                        //.sendToTarget();            } catch (IOException e) {                Log.e(TAG, Exception during write, e);            }        }        public void cancel() {            try {                mmSocket.close();            } catch (IOException e) {                Log.e(TAG, close() of connect socket failed, e);            }        }    }}
MVC in Android development for Bluetooth application
java;android;bluetooth
You should be able to add the instantiated object to your intents. This way, you should be able to access it in other Activities or Services.You might want to investigate on services if you want the app to do something consistently and should be able to get information from the service via intent.As for MVC see: https://stackoverflow.com/questions/2925054/mvc-pattern-in-android