Tv App Develop of OAD Architecture

這篇blog主要記錄oad 的架構，及其OAD SCAN 狀態機機制。
–>Activity，Service，Handler，Thread，Looper之間的交互機制。
–>OAD SCAN State Mechanism.

1: OAD Architecture

1.1: OADActivity

public class OADActivity extends Activity {
    OADFSMService mService;
    private String TAG = this.getClass().getSimpleName();
    Intent mIntent;

    @Override
        protected void onCreate(Bundle savedInstanceState) {
            // TODO Auto-generated method stub
            super.onCreate(savedInstanceState);
            setContentView(R.layout.oadmsgactivity);
            mIntent = getIntent();
            bindService(new Intent("org.droidtv.oad.services.OADFSMService"),
                    mConnection, Context.BIND_AUTO_CREATE);
        }

    @Override
        protected void onNewIntent(Intent intent) {
            // TODO Auto-generated method stub
            super.onNewIntent(intent);
            mIntent = intent;
            if(mService==null){
                bindService(new Intent("org.droidtv.oad.services.OADFSMService"),mConnection, Context.BIND_AUTO_CREATE);
            }
        }
}

bind oad service

private ServiceConnection mConnection = new ServiceConnection() {
        // Called when the connection with the service is established
        public void onServiceConnected(ComponentName className, IBinder service) {
            // Because we have bound to an explicit
            // service that is running in our own process, we can
            // cast its IBinder to a concrete class and directly access it.
            OADFSMServiceBinder binder = (OADFSMServiceBinder) service;
            mService = binder.getService();
        }

        // Called when the connection with the service disconnects unexpectedly
        public void onServiceDisconnected(ComponentName className) {
            Log.e(TAG, "onServiceDisconnected");
            mService = null;
        }
    };

1.2: OADService:

    private void OADFSMServiceInit() {
        Log.d(tag, "Initializing OADFSMService ");
        try {
            initFSM();
            Callback msgCallback = new Callback() {
                @Override
                    public boolean handleMessage(Message msg) {
                        // TODO Auto-generated method stub
                        Log.d(tag, "inside handler to handle Message for value = "  + msg.arg1);

                        try {
                            FSM fsm = statemachine[msg.arg1][mOadScanState.ordinal()];

                            if (fsm != null) {
                                fsm.action();
                            }else{
                                Log.d(tag, "statemachine is fsm is null");
                            }
                        } catch (Exception e) {
                            Log.d(tag, "Exception on statemachine action: " + e.toString());
                        }

                        return false;
                    }
            };
            mOADHandler = new oadMsgHandler(oadMsgHandler.getLooper("OADFSMService"), msgCallback);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

1.3: Handler/Thread/Looper

public class oadMsgHandler extends Handler{

    public oadMsgHandler(Looper looper, Callback cb) {
        super(looper,cb);
    }

    public oadMsgHandler(Callback cb) {
        super(cb);
    }

    public static Looper getLooper(String threadname) {
        try {
            HandlerThread thread = new HandlerThread(threadname, android.os.Process.THREAD_PRIORITY_BACKGROUND);
            thread.start();
            return thread.getLooper();
        }
        catch(Exception e) {
            return null;
        }
    }

    public static Looper getLooper(String threadname,int priority) {
        try {
            HandlerThread thread = new HandlerThread(threadname, priority);
            thread.start();
            return thread.getLooper();
        }
        catch(Exception e) {
            return null;
        }
    }
}

2: OAD Scan State Mechanism

2.1: FSM init

    private void initFSM() {
        Log.d(tag, "Initializing finite State machine");
        statemachine = new FSM[][] {
                /*******************************     preffered mux scanning process    **********************************/
                /*                                   CbmhgOadScanIdle          CbmhgOadScanInProgress     CbmhgOadScanStopping */
                /*CbmhgOadPrefferedScanStart     */  {StartPrefferedScan      ,null                      ,null                 },
                /*CbmhgOadPrefferedScanTsLocked  */  {null                    ,PrefferedTsLocked         ,null                 },
                /*CbmhgOadPrefferedScanTsNotFound*/  {null                    ,PrefferedTsNotFound       ,null                 },
                /*CbmhgOadPrefferedScanNextTs    */  {null                    ,PrefferedScanNextTs       ,null                 },
                /*CbmhgOadPrefferedScanComplete  */  {null                    ,ScanComplete              ,ScanComplete         },
                /*CbmhgOadPrefferedScanStop      */  {null                    ,StopScan                  ,null                 },


                /******************************************************************************************************************/
                /*********************************   frequencyList scanning process      *********************************/
                /*                                   CbmhgOadScanIdle         CbmhgOadScanInProgress     CbmhgOadScanStopping */
                /*CbmhgOadFrequencyScanStart     */  {StartFrequencyListScan   ,null                      ,null                  },
                /*CbmhgOadFrequencyScanTsLocked  */  {null                     ,FrequencyListTsLocked     ,null                  },
                /*CbmhgOadFrequencyScanTsNotFound*/  {null                     ,FrequencyListTsNotFound   ,null                  },
                /*CbmhgOadFrequencyScanNextTs    */  {null                     ,FrequencyListScanNextTs   ,null                  },
                /*CbmhgOadFrequencyScanComplete  */  {null                     ,ScanComplete              ,ScanComplete          },
                /*CbmhgOadFrequencyScanStop      */  {null                     ,StopScan                  ,null                  }
                /******************************************************************************************************************/
        };
    }

2.2: scan state change

    private final FSM PrefferedScanNextTs = new FSM() {
        @Override
            public void action() {
                Log.d(tag, "Inside PrefferedScanNextTs action");
                if( (signleTuneResult == 0)) {
                    if (NONE != GetNextScanMode(PREFFERED)) {
                        isPrefScanCompleted = true;
                        mOadScanState = CbmhgOadStates.CbmhgOadScanIdle;
                        mOadScanModeState = FREQUENCYLIST;
                        synchronized (mOADHandler) {
                            Message msg = mOADHandler.obtainMessage();
                            msg.arg1 = CbmhgOadScanEvents.CbmhgOadFrequencyScanStart.ordinal();
                            mOADHandler.sendMessage(msg);
                        }
                    }
                }
            }
    };

3: OAD Observer Mode

這個文件並沒有用，只是記錄下如何使用Android Observe模式

3.1: observable

public class NotificationHandler extends Observable {
    private static NotificationHandler notificationHandler;

    private NotificationHandler(){
    }

    public static NotificationHandler getInstance(){
        if(notificationHandler == null){
            notificationHandler = new NotificationHandler();
        }
        return notificationHandler;
    }

    public void registerForNotifications(Observer observer){
        addObserver(observer);
    }

    public void unregisterFromNotifications(Observer observer){
        deleteObserver(observer);
    }

    public void removeAllNotification(){
        deleteObservers();
    }

    public void notifyAllObservers(int actionID,int  id)
    {
        setChanged();
        Log.i("NotificationHandler:","message:"+id);
        Log.i("NotificationHandler:","actionID:"+actionID);
        notificationHandler.notifyObservers(new NotificationInfoObject(actionID, id));
    }
}

3.2: observe

public interface OADInterface extends Observer
{
     void screenIntialization();
}

4: Download

https://code.csdn.net/dashboard/index