xref: /packages/apps/Bluetooth/tests/src/com/android/bluetooth/tests/ObexTest.java

/*
* Copyright (C) 2014 Samsung System LSI
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*      http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

package com.android.bluetooth.tests;

import java.io.IOException;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;
import java.util.ArrayList;
import java.util.concurrent.CountDownLatch;

import javax.obex.HeaderSet;
import javax.obex.ObexTransport;
import javax.obex.Operation;
import javax.obex.ResponseCodes;
import javax.obex.ServerRequestHandler;

import junit.framework.Assert;
import android.annotation.TargetApi;
import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothServerSocket;
import android.bluetooth.BluetoothSocket;
import android.bluetooth.BluetoothUuid;
import android.bluetooth.SdpMasRecord;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.net.LocalServerSocket;
import android.net.LocalSocket;
import android.os.Build;
import android.os.Debug;
import android.os.ParcelUuid;
import android.test.AndroidTestCase;
import android.util.Log;

import com.android.bluetooth.BluetoothObexTransport;
import com.android.bluetooth.sdp.SdpManager;
import com.android.bluetooth.tests.TestSequencer.OPTYPE;

/**
 * Test either using the reference ril without a modem, or using a RIL implementing the
 * BT SAP API, by providing the rild-bt socket as well as the extended API functions for SAP.
 *
 */
@TargetApi(Build.VERSION_CODES.KITKAT)
public class ObexTest extends AndroidTestCase implements ITestSequenceConfigurator {
    protected static String TAG = "ObexTest";
    protected static final boolean D = true;
    protected static final boolean TRACE = false;
    protected static final boolean DELAY_PASS_30_SEC = false;
    public static final long PROGRESS_INTERVAL_MS = 1000;
    private static final ObexTestParams defaultParams =
            new ObexTestParams(2*8092, 0, 2*1024*1024);

    private static final ObexTestParams throttle100Params =
            new ObexTestParams(2*8092, 100000, 1024*1024);

    private static final ObexTestParams smallParams =
            new ObexTestParams(2*8092, 0, 2*1024);

    private static final ObexTestParams hugeParams =
            new ObexTestParams(2*8092, 0, 100*1024*1024);

    private static final int SMALL_OPERATION_COUNT = 1000;
    private static final int CONNECT_OPERATION_COUNT = 4500;

    private static final int L2CAP_PSM = 29; /* If SDP is not used */
    private static final int RFCOMM_CHANNEL = 29; /* If SDP is not used */

    //public static final String SERVER_ADDRESS = "10:68:3F:5E:F9:2E";
    public static final String SERVER_ADDRESS = "F8:CF:C5:A8:70:7E";

    private static final String SDP_SERVER_NAME = "Samsung Server";
    private static final String SDP_CLIENT_NAME = "Samsung Client";

    private static final long SDP_FEATURES  = 0x87654321L; /* 32 bit */
    private static final int SDP_MSG_TYPES  = 0xf1;       /*  8 bit */
    private static final int SDP_MAS_ID     = 0xCA;       /*  8 bit */
    private static final int SDP_VERSION    = 0xF0C0;     /* 16 bit */
    public static final ParcelUuid SDP_UUID_OBEX_MAS = BluetoothUuid.MAS;

    private static int sSdpHandle = -1;
    private static final ObexTestDataHandler sDataHandler = new ObexTestDataHandler("(Client)");
    private static final ISeqStepValidator sResponseCodeValidator = new ResponseCodeValidator();
    private static final ISeqStepValidator sDataValidator = new DataValidator();


    private enum SequencerType {
        SEQ_TYPE_PAYLOAD,
        SEQ_TYPE_CONNECT_DISCONNECT
    }

    private Context mContext = null;
    private int mChannelType = 0;

    public ObexTest() {
        super();
    }

    /**
     * Test that a connection can be established.
     * WARNING: The performance of the pipe implementation is not good. I'm only able to get a
     * throughput of around 220 kbyte/sec - less that when using Bluetooth :-)
     * UPDATE: Did a local socket implementation below to replace this...
     *         This has a throughput of more than 4000 kbyte/s
     */
    public void testLocalPipes() {
        mContext = this.getContext();
        System.out.println("Setting up pipes...");

        PipedInputStream clientInStream = null;
        PipedOutputStream clientOutStream = null;
        PipedInputStream serverInStream = null;
        PipedOutputStream serverOutStream = null;
        ObexPipeTransport clientTransport = null;
        ObexPipeTransport serverTransport = null;

        try {
            /* Create and interconnect local pipes for transport */
            clientInStream = new PipedInputStream(5*8092);
            clientOutStream = new PipedOutputStream();
            serverInStream = new PipedInputStream(clientOutStream, 5*8092);
            serverOutStream = new PipedOutputStream(clientInStream);

            /* Create the OBEX transport objects to wrap the pipes - enable SRM */
            clientTransport = new ObexPipeTransport(clientInStream, clientOutStream, true);
            serverTransport = new ObexPipeTransport(serverInStream, serverOutStream, true);

            TestSequencer sequencer = createBtPayloadTestSequence(clientTransport, serverTransport);

            //Debug.startMethodTracing("ObexTrace");
            assertTrue(sequencer.run(mContext));
            //Debug.stopMethodTracing();
        } catch (IOException e) {
            Log.e(TAG, "IOException", e);
        }
    }

    /**
     * Run the test sequence using a local socket.
     * Throughput around 4000 kbyte/s - with a larger OBEX package size.
     */
    public void testLocalSockets() {
        mContext = this.getContext();
        System.out.println("Setting up sockets...");

        try {
            /* Create and interconnect local pipes for transport */
            LocalServerSocket serverSock = new LocalServerSocket("com.android.bluetooth.tests.sock");
            LocalSocket clientSock = new LocalSocket();
            LocalSocket acceptSock;

            clientSock.connect(serverSock.getLocalSocketAddress());

            acceptSock = serverSock.accept();

            /* Create the OBEX transport objects to wrap the pipes - enable SRM */
            ObexPipeTransport clientTransport = new ObexPipeTransport(clientSock.getInputStream(),
                    clientSock.getOutputStream(), true);
            ObexPipeTransport serverTransport = new ObexPipeTransport(acceptSock.getInputStream(),
                    acceptSock.getOutputStream(), true);

            TestSequencer sequencer = createBtPayloadTestSequence(clientTransport, serverTransport);

            //Debug.startMethodTracing("ObexTrace");
            assertTrue(sequencer.run(mContext));
            //Debug.stopMethodTracing();

            clientSock.close();
            acceptSock.close();
            serverSock.close();
        } catch (IOException e) {
            Log.e(TAG, "IOException", e);
        }
    }

    /* Create a sequence of put/get operations with different payload sizes */
    private TestSequencer createBtPayloadTestSequence(ObexTransport clientTransport,
            ObexTransport serverTransport)
            throws IOException {
        TestSequencer sequencer = new TestSequencer(clientTransport, serverTransport, this);
        SeqStep step;

        step = sequencer.addStep(OPTYPE.CONNECT, sResponseCodeValidator);
        if(false){

        step = sequencer.addStep(OPTYPE.PUT, sDataValidator);
        step.mParams = defaultParams;
        step.mUseSrm = true;

        step = sequencer.addStep(OPTYPE.GET, sDataValidator);
        step.mParams = defaultParams;
        step.mUseSrm = true;

        step = sequencer.addStep(OPTYPE.PUT, sDataValidator);
        step.mParams = throttle100Params;
        step.mUseSrm = true;

        step = sequencer.addStep(OPTYPE.GET, sDataValidator);
        step.mParams = throttle100Params;
        step.mUseSrm = true;

        for(int i=0; i<SMALL_OPERATION_COUNT; i++){
            step = sequencer.addStep(OPTYPE.PUT, sDataValidator);
            step.mParams = smallParams;
            step.mUseSrm = true;

            step = sequencer.addStep(OPTYPE.GET, sDataValidator);
            step.mParams = smallParams;
            step.mUseSrm = true;

        }
}

        step = sequencer.addStep(OPTYPE.PUT, sDataValidator);
        step.mParams = hugeParams;
        step.mUseSrm = true;

        step = sequencer.addStep(OPTYPE.GET, sDataValidator);
        step.mParams = hugeParams;
        step.mUseSrm = true;
        step = sequencer.addStep(OPTYPE.DISCONNECT, sResponseCodeValidator);

        return sequencer;
    }

    private TestSequencer createBtConnectTestSequence(ObexTransport clientTransport,
            ObexTransport serverTransport)
            throws IOException {
        TestSequencer sequencer = new TestSequencer(clientTransport, serverTransport, this);
        SeqStep step;

            step = sequencer.addStep(OPTYPE.CONNECT, sResponseCodeValidator);

            step = sequencer.addStep(OPTYPE.PUT, sDataValidator);
            step.mParams = smallParams;
            step.mUseSrm = true;

            step = sequencer.addStep(OPTYPE.GET, sDataValidator);
            step.mParams = smallParams;
            step.mUseSrm = true;

            step = sequencer.addStep(OPTYPE.DISCONNECT, sResponseCodeValidator);

        return sequencer;
    }


    /**
     * Use this validator to validate operation response codes. E.g. for OBEX CONNECT and
     * DISCONNECT operations.
     * Expects HeaderSet to be valid, and Operation to be null.
     */
    public static ISeqStepValidator getResponsecodevalidator() {
        return sResponseCodeValidator;
    }

    /**
     * Use this validator to validate (and read/write data) for OBEX PUT and GET operations.
     * Expects Operation to be valid, and HeaderSet to be null.
     */
    public static ISeqStepValidator getDatavalidator() {
        return sDataValidator;
    }

    /**
     * Use this validator to validate operation response codes. E.g. for OBEX CONNECT and
     * DISCONNECT operations.
     * Expects HeaderSet to be valid, and Operation to be null.
     */
    private static class ResponseCodeValidator implements ISeqStepValidator {

        protected static boolean validateHeaderSet(HeaderSet headers, HeaderSet expected)
                throws IOException {
            if(headers.getResponseCode() != ResponseCodes.OBEX_HTTP_OK) {
                Log.e(TAG,"Wrong ResponseCode: " + headers.getResponseCode());
                Assert.assertTrue(false);
                return false;
            }
            return true;
        }

        @Override
        public boolean validate(SeqStep step, HeaderSet response, Operation op)
                throws IOException {
            if(response == null) {
                if(op.getResponseCode() != ResponseCodes.OBEX_HTTP_OK) {
                    Log.e(TAG,"Wrong ResponseCode: " + op.getResponseCode());
                    Assert.assertTrue(false);
                    return false;
                }
                return true;
            }
            return validateHeaderSet(response, step.mResHeaders);
        }
    }

    /**
     * Use this validator to validate (and read/write data) for OBEX PUT and GET operations.
     * Expects Operation to ve valid, and HeaderSet to be null.
     */
    private static class DataValidator implements ISeqStepValidator {
        @Override
        public boolean validate(SeqStep step, HeaderSet notUsed, Operation op)
        throws IOException {
            Assert.assertNotNull(op);
            if(step.mType == OPTYPE.GET) {
                op.noBodyHeader();
                sDataHandler.readData(op.openDataInputStream(), step.mParams);
            } else if (step.mType == OPTYPE.PUT) {
                sDataHandler.writeData(op.openDataOutputStream(), step.mParams);
            }
            int responseCode = op.getResponseCode();
            Log.i(TAG, "response code: " + responseCode);
            HeaderSet response = op.getReceivedHeader();
            ResponseCodeValidator.validateHeaderSet(response, step.mResHeaders);
            op.close();
            return true;
        }
    }

    public void testBtServerL2cap() {
        testBtServer(BluetoothSocket.TYPE_L2CAP, false, SequencerType.SEQ_TYPE_PAYLOAD);
    }

    public void testBtServerRfcomm() {
        testBtServer(BluetoothSocket.TYPE_RFCOMM, false, SequencerType.SEQ_TYPE_PAYLOAD);
    }

    public void testBtClientL2cap() {
        testBtClient(BluetoothSocket.TYPE_L2CAP, false, SequencerType.SEQ_TYPE_PAYLOAD);
    }

    public void testBtClientRfcomm() {
        testBtClient(BluetoothSocket.TYPE_RFCOMM, false, SequencerType.SEQ_TYPE_PAYLOAD);
    }

    public void testBtServerSdpL2cap() {
        testBtServer(BluetoothSocket.TYPE_L2CAP, true, SequencerType.SEQ_TYPE_PAYLOAD);
    }

    public void testBtServerSdpRfcomm() {
        testBtServer(BluetoothSocket.TYPE_RFCOMM, true, SequencerType.SEQ_TYPE_PAYLOAD);
    }

    public void testBtClientSdpL2cap() {
        testBtClient(BluetoothSocket.TYPE_L2CAP, true, SequencerType.SEQ_TYPE_PAYLOAD);
    }

    public void testBtClientSdpRfcomm() {
        testBtClient(BluetoothSocket.TYPE_RFCOMM, true, SequencerType.SEQ_TYPE_PAYLOAD);
    }

    public void testBtServerConnectL2cap() {
        for(int i=0; i<CONNECT_OPERATION_COUNT; i++){
            Log.i(TAG, "Starting iteration " + i);
            testBtServer(BluetoothSocket.TYPE_L2CAP, true,
                    SequencerType.SEQ_TYPE_CONNECT_DISCONNECT);
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                Log.e(TAG,"Exception while waiting...",e);
            }
        }
    }

    public void testBtClientConnectL2cap() {
        for(int i=0; i<CONNECT_OPERATION_COUNT; i++){
            Log.i(TAG, "Starting iteration " + i);
            testBtClient(BluetoothSocket.TYPE_L2CAP, true,
                    SequencerType.SEQ_TYPE_CONNECT_DISCONNECT);
            try {
                // We give the server 100ms to allow adding SDP record
                Thread.sleep(150);
            } catch (InterruptedException e) {
                Log.e(TAG,"Exception while waiting...",e);
            }
        }
    }

    public void testBtServerConnectRfcomm() {
        for(int i=0; i<CONNECT_OPERATION_COUNT; i++){
            Log.i(TAG, "Starting iteration " + i);
            testBtServer(BluetoothSocket.TYPE_RFCOMM, true,
                    SequencerType.SEQ_TYPE_CONNECT_DISCONNECT);
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                Log.e(TAG,"Exception while waiting...",e);
            }
        }
    }

    public void testBtClientConnectRfcomm() {
        for(int i=0; i<CONNECT_OPERATION_COUNT; i++){
            Log.i(TAG, "Starting iteration " + i);
            testBtClient(BluetoothSocket.TYPE_RFCOMM, true,
                    SequencerType.SEQ_TYPE_CONNECT_DISCONNECT);
            try {
                // We give the server 100ms to allow adding SDP record
                Thread.sleep(250);
            } catch (InterruptedException e) {
                Log.e(TAG,"Exception while waiting...",e);
            }
        }
    }

    /**
     * Create a serverSocket
     * @param type
     * @param useSdp
     * @return
     * @throws IOException
     */
    public static BluetoothServerSocket createServerSocket(int type, boolean useSdp)
            throws IOException {
        int rfcommChannel = -1;
        int l2capPsm = -1;

        BluetoothAdapter bt = BluetoothAdapter.getDefaultAdapter();
        if(bt == null) {
            Log.e(TAG,"No Bluetooth Device!");
            assertTrue(false);
        }
        BluetoothTestUtils.enableBt(bt);
        BluetoothServerSocket serverSocket=null;
        if(type == BluetoothSocket.TYPE_L2CAP) {
            if(useSdp == true) {
                serverSocket = bt.listenUsingL2capOn(
                        BluetoothAdapter.SOCKET_CHANNEL_AUTO_STATIC_NO_SDP);
            } else {
                serverSocket = bt.listenUsingL2capOn(L2CAP_PSM);
            }
            l2capPsm = serverSocket.getChannel();
            Log.d(TAG, "L2CAP createde, PSM: " + l2capPsm);
        } else if(type == BluetoothSocket.TYPE_RFCOMM) {
            if(useSdp == true) {
                serverSocket = bt.listenUsingInsecureRfcommOn(
                        BluetoothAdapter.SOCKET_CHANNEL_AUTO_STATIC_NO_SDP);
            } else {
                serverSocket = bt.listenUsingInsecureRfcommOn(RFCOMM_CHANNEL);
            }
            rfcommChannel = serverSocket.getChannel();
            Log.d(TAG, "RFCOMM createde, Channel: " + rfcommChannel);
        } else {
            fail("Invalid transport type!");
        }
        if(useSdp == true) {
            /* We use the MAP service record to be able to set rfcomm and l2cap channels */
            // TODO: We need to free this
            if(sSdpHandle >= 0) {
                SdpManager.getDefaultManager().removeSdpRecord(sSdpHandle);
            }
            Log.d(TAG, "Creating record with rfcomm channel: " + rfcommChannel +
                    " and l2cap channel: " + l2capPsm);
            sSdpHandle = SdpManager.getDefaultManager().createMapMasRecord(SDP_SERVER_NAME,
                    SDP_MAS_ID, rfcommChannel, l2capPsm,
                    SDP_VERSION, SDP_MSG_TYPES, (int)(SDP_FEATURES & 0xffffffff));
        } else {
            Log.d(TAG, "SKIP creation of record with rfcomm channel: " + rfcommChannel +
                    " and l2cap channel: " + l2capPsm);
        }
        return serverSocket;
    }

    public static void removeSdp() {
        if(sSdpHandle > 0) {
            SdpManager.getDefaultManager().removeSdpRecord(sSdpHandle);
            sSdpHandle = -1;
        }
    }

    /**
     * Server side of a two device Bluetooth test of OBEX
     */
    private void testBtServer(int type, boolean useSdp, SequencerType sequencerType) {
        mContext = this.getContext();
        Log.d(TAG,"Starting BT Server...");

        if(TRACE) Debug.startMethodTracing("ServerSide");
        try {
            BluetoothServerSocket serverSocket=createServerSocket(type, useSdp);

            Log.i(TAG, "Waiting for client to connect");
            BluetoothSocket socket = serverSocket.accept();
            Log.i(TAG, "Client connected");

            BluetoothObexTransport serverTransport = new BluetoothObexTransport(socket);
            TestSequencer sequencer = null;
            switch(sequencerType) {
            case SEQ_TYPE_CONNECT_DISCONNECT:
                sequencer = createBtConnectTestSequence(null, serverTransport);
                break;
            case SEQ_TYPE_PAYLOAD:
                sequencer = createBtPayloadTestSequence(null, serverTransport);
                break;
            default:
                fail("Invalid sequencer type");
                break;

            }
            //Debug.startMethodTracing("ObexTrace");
            assertTrue(sequencer.run(mContext));
            //Debug.stopMethodTracing();
            // Same as below... serverTransport.close();
            // This is done by the obex server socket.close();
            serverSocket.close();
            removeSdp();
            sequencer.shutdown();
        } catch (IOException e) {
            Log.e(TAG, "IOException", e);
        }
        if(TRACE) Debug.stopMethodTracing();
        if(DELAY_PASS_30_SEC) {
            Log.i(TAG, "\n\n\nTest done - please fetch logs within 30 seconds...\n\n\n");
            try {
                Thread.sleep(30000);
            } catch (InterruptedException e) {}
        }
        Log.i(TAG, "Test done.");
    }

    /**
     * Enable Bluetooth and connect to a server socket
     * @param type
     * @param useSdp
     * @param context
     * @return
     * @throws IOException
     */
    static public BluetoothSocket connectClientSocket(int type, boolean useSdp, Context context)
            throws IOException {
        int rfcommChannel = RFCOMM_CHANNEL;
        int l2capPsm = L2CAP_PSM;

        BluetoothAdapter bt = BluetoothAdapter.getDefaultAdapter();
        if(bt == null) {
            Log.e(TAG,"No Bluetooth Device!");
            assertTrue(false);
        }
        BluetoothTestUtils.enableBt(bt);
        BluetoothDevice serverDevice = bt.getRemoteDevice(SERVER_ADDRESS);

        if(useSdp == true) {
            SdpMasRecord record = clientAwaitSdp(serverDevice, context);
            rfcommChannel = record.getRfcommCannelNumber();
            l2capPsm = record.getL2capPsm();
        }

        BluetoothSocket socket = null;
        if(type == BluetoothSocket.TYPE_L2CAP) {
            socket = serverDevice.createL2capSocket(l2capPsm);
        } else if(type == BluetoothSocket.TYPE_RFCOMM) {
            socket = serverDevice.createRfcommSocket(rfcommChannel);
        } else {
            fail("Invalid transport type!");
        }

        socket.connect();

        return socket;
    }

    /**
     * Test that a connection can be established.
     */
    private void testBtClient(int type, boolean useSdp, SequencerType sequencerType) {
        mContext = this.getContext();
        mChannelType = type;
        BluetoothSocket socket = null;
        System.out.println("Starting BT Client...");
        if(TRACE) Debug.startMethodTracing("ClientSide");
        try {
            socket = connectClientSocket(type, useSdp, mContext);

            BluetoothObexTransport clientTransport = new BluetoothObexTransport(socket);

            TestSequencer sequencer = null;
            switch(sequencerType) {
            case SEQ_TYPE_CONNECT_DISCONNECT:
                sequencer = createBtConnectTestSequence(clientTransport, null);
                break;
            case SEQ_TYPE_PAYLOAD:
                sequencer = createBtPayloadTestSequence(clientTransport, null);
                break;
            default:
                fail("Invalid test type");
                break;

            }
            //Debug.startMethodTracing("ObexTrace");
            assertTrue(sequencer.run(mContext));
            //Debug.stopMethodTracing();
            socket.close(); // Only the streams are closed by the obex client
            sequencer.shutdown();

        } catch (IOException e) {
            Log.e(TAG, "IOException", e);
        }
        if(TRACE) Debug.stopMethodTracing();
        if(DELAY_PASS_30_SEC) {
            Log.i(TAG, "\n\n\nTest done - please fetch logs within 30 seconds...\n\n\n");
            try {
                Thread.sleep(30000);
            } catch (InterruptedException e) {}
        }
        Log.i(TAG, "Test done.");
    }

    /* Using an anonymous class is not efficient, but keeps a tight code structure. */
    static class SdpBroadcastReceiver extends BroadcastReceiver {
        private SdpMasRecord mMasRecord; /* A non-optimal way of setting an object reference from
                                            a anonymous class. */
        final CountDownLatch mLatch;
        public SdpBroadcastReceiver(CountDownLatch latch) {
            mLatch = latch;
        }

        SdpMasRecord getMasRecord() {
            return mMasRecord;
        }

        @Override
        public void onReceive(Context context, Intent intent) {
            Log.d(TAG, "onReceive");
            String action = intent.getAction();
            if (action.equals(BluetoothDevice.ACTION_SDP_RECORD)){
                Log.v(TAG, "Received ACTION_SDP_RECORD.");
                ParcelUuid uuid = intent.getParcelableExtra(BluetoothDevice.EXTRA_UUID);
                Log.v(TAG, "Received UUID: " + uuid.toString());
                Log.v(TAG, "existing UUID: " + SDP_UUID_OBEX_MAS.toString());
                if(uuid.toString().equals(SDP_UUID_OBEX_MAS.toString())) {
                    assertEquals(SDP_UUID_OBEX_MAS.toString(), uuid.toString());
                    Log.v(TAG, " -> MAS UUID in result.");
                    SdpMasRecord record = intent.getParcelableExtra(
                            BluetoothDevice.EXTRA_SDP_RECORD);
                    assertNotNull(record);
                    Log.v(TAG, " -> record: "+record);
                    if(record.getServiceName().equals(SDP_SERVER_NAME)) {

                        assertEquals(((long)record.getSupportedFeatures())
                                &0xffffffffL, SDP_FEATURES);

                        assertEquals(record.getSupportedMessageTypes(), SDP_MSG_TYPES);

                        assertEquals(record.getProfileVersion(), SDP_VERSION);

                        assertEquals(record.getServiceName(), SDP_SERVER_NAME);

                        assertEquals(record.getMasInstanceId(), SDP_MAS_ID);

                        int status = intent.getIntExtra(BluetoothDevice.EXTRA_SDP_SEARCH_STATUS,
                                -1);
                        Log.v(TAG, " -> status: "+status);
                        mMasRecord = record;
                        mLatch.countDown();
                    } else {
                        Log.i(TAG, "Wrong service name (" + record.getServiceName()
                                + ") received, still waiting...");
                    }
                } else {
                    Log.i(TAG, "Wrong UUID received, still waiting...");
                }
            } else {
                fail("Unexpected intent received???");
            }
        }
    };


    private static SdpMasRecord clientAwaitSdp(BluetoothDevice serverDevice, Context context) {
        IntentFilter filter = new IntentFilter();
        filter.addAction(BluetoothDevice.ACTION_SDP_RECORD);
        final CountDownLatch latch = new CountDownLatch(1);
        SdpBroadcastReceiver broadcastReceiver = new SdpBroadcastReceiver(latch);

        context.registerReceiver(broadcastReceiver, filter);

        serverDevice.sdpSearch(SDP_UUID_OBEX_MAS);
        boolean waiting = true;
        while(waiting == true) {
            try {
                Log.i(TAG, "SDP Search requested - awaiting result...");
                latch.await();
                Log.i(TAG, "SDP Search reresult received - continueing.");
                waiting = false;
            } catch (InterruptedException e) {
                Log.w(TAG, "Interrupted witle waiting - keep waiting.", e);
                waiting = true;
            }
        }
        context.unregisterReceiver(broadcastReceiver);
        return broadcastReceiver.getMasRecord();
    }

    @Override
    public ServerRequestHandler getObexServer(ArrayList<SeqStep> sequence,
            CountDownLatch stopLatch) {
        return new ObexTestServer(sequence, stopLatch);
    }



}