Initialization and updating Fragments in ViewPager

Question

I'm writing an application that uses bluetooth connection to read some data from COM port over bluetooth. I am using ViewPager to display several Fragments which I use to show some data (each Fragment in a different way). The app has 2 activities:

1. MainActivity - initialization of the bluetooth connection and managing mentioned fragments
2. Activity used to search for bluetooth devices

When MainActivity starts, it activates the bluetooth in case it's off and displays first of the fragments. I can scan for devices by pressing the button in the action panel.

My problem is quite simple - I'd like to push some initial data (about connection) to fragments after initialization of the MainActivity, and after making a BT connection I want to push some data (about 10 reads/sec) only to a visible fragment.

I tried to do this by using LocalBroadcastManager in all of the fragments, but the broadcastReceiver is not registered that early and it don't receive all of the messages. I tried to move registration to onCreate in the fragments classes but it didn't work either. I've also tried to implement callback interface to the main activity but I was getting NPE.

Besides that one issue I'm worried it might not be the best solution to the problem of updating one or more fragments about the changes. I'm open to advices.

Mainactivity class:

@Override
protected void onStart() {
    super.onStart();

    if (!bluetoothAdapter.isEnabled()) {
        Intent enableBluetoothIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
        startActivityForResult(enableBluetoothIntent, REQUEST_ENABLE_BLUETOOTH);
    } else {
        if (btService == null) {
            btService = new BluetoothConnectionService(this, msgHandler);
        }
    }
}

private final Handler msgHandler = new Handler() {
    @Override
    public void handleMessage(Message msg) {
        Intent intent = new Intent(STATUS_EVENT);
        switch (msg.what) {
            case MESSAGE_STATE_CHANGE:
                switch (msg.arg1) {
                    case BluetoothConnectionService.STATE_CONNECTED:
                        intent.putExtra("status", "Connected");
                        // tell fragments about the state change
                        break;
                    case BluetoothConnectionService.STATE_CONNECTING:
                        intent.putExtra("status", "Connecting");
                        // tell fragments about the state change
                        break;
                    case BluetoothConnectionService.STATE_NONE:
                        intent.putExtra("status", "Not connected");
                        // tell fragments about the state change
                        break;
                    default:
                        intent.putExtra("status","Unknown state");
                        break;
                }                  
        LocalBroadcastManager.getInstance(getApplicationContext()).sendBroadcast(intent);
        }
    }
};

BTService part:

public void setCurrentConnectionState(int currentConnectionState) {
    this.currentConnectionState = currentConnectionState;

    msgHandler.obtainMessage(MainActivity.MESSAGE_STATE_CHANGE, currentConnectionState, -1).sendToTarget();
}

public BluetoothConnectionService(Context context, Handler handler){
    this.context = context;
    this.msgHandler = handler;
    setCurrentConnectionState(STATE_NONE);
}

One of the fragments:

public class ConnectionStatusFragment extends Fragment {

TextView connectionStatus;

@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
                         Bundle savedInstanceState) {

    View rootView = inflater.inflate(R.layout.fragment_connection_info, container, false);
    connectionStatus = (TextView) rootView.findViewById(R.id.connectionStatus);
    LocalBroadcastManager.getInstance(getActivity()).registerReceiver(broadcastReceiver, new IntentFilter(MainActivity.STATUS_EVENT));
    return rootView;
}

private final BroadcastReceiver broadcastReceiver = new BroadcastReceiver() {
    @Override
    public void onReceive(Context context, Intent intent) {         
        connectionStatus.setText(intent.getStringExtra("status"));
    }

};

}

Answer 1

Rethink your design along MVC lines and apply it in android to Data-Model which collaborates in MVC fashion with adapters/Views used by Fragments. Adapters inside your fragments are hooked to data-changed events that originate in the model...

In background, off the UI and orthogonal to your fragments, establish your connections and update your Data-Model. No need to pass information about BT connections to your fragments. Why violate a separation of concerns? Its your model that needs to know about BT connections, not your VIEW!

All the connections and IO for updating your data-model are encapsulated in your MODEL actions/processes. Your View does not have to know anything other than "data-model-changed". All that your fragment has to have is the Event(data-has-changed) so that it can fire 'Has-changed' for your adapter -which will then take care of updating the UI in the appropriate fragment.

Applying this practically to android/fragments and guessing a little about your design, i think that the contstructors for your fragments can utilize an interface that allows you to construct the View/Fragment regardless of the state of your actual data-model. At the time of instantiation, the fragment and its adapter do not know everything about the state of the data arriving on the BT connection in a different module. The fragment just needs to use an interface to accommodate the 'model-has-changed' event.

I think you can use the 'looper' and a handler for that collaboration around the event. This might mean that the Model would need a reference to the handler object over in the View/fragment class. That handler is for messages containing state-changes from the model.

module coordination in steps:

1. construct fragment/View - object exists , view hidden , no data

1.a. construct handler in fragment, creating reference to the receiver object for messages on the looper

2.a. Construct model, including ref to the above handler.

2.b. Do the BT stuff and IO in the model. When 'model-changed', obtain the message whose content signals what your view will need to know about 'model-changed'.

2.c. Send the message which will be received by the handler over in the View layer/fragment (see 1.a.).

Sample:

see very end of answer here to see how the fragment/View receives messages from the looper and then adjusts the UI...