However, by the time I developed the 1stapp, it still seemed like a lot of code. Of course this kind of an app is meant to do a lot more than just say ‘Hello World’. It’s power is best utilized in developing games, I would say.
Like the poker game that is available in the Samsung Android developer documentation.
So, What are the steps to start with?
Step 1: You first need to create a channel. I do this when I initialize my service. I have written a service that gets an instance of the ChordManager.
public voidinitialize(IChordServiceListener csListener) {
if (mChord != null) {
return;
}
mChord = ChordManager.getInstance(this);
mListener = csListener;
mChord.setTempDirectory(chordFilePath);
mChord.setHandleEventLooper(getMainLooper());
…
}
Note that I have got an ChordManager here and associated a temporary file path and a the app’s main looper.
Step 2: Next, You would want a way to join the channel So, let us implement the joinChannel() method and leaveChannel() method as its complement.
This is after the ChordManager is up and running.
public IChordChannel joinChannel(String channelName) {
if (channelName == null || channelName.equals("")) {
mPrivateChannelName = MYCHANNEL;
} else {
mPrivateChannelName = channelName;
}
IChordChannel channelInst = mChord.joinChannel(mPrivateChannelName, mChannelListener);
if (null == channelInst) {
return null;
}
return channelInst;
}
This seems straight forward. MYCHANNEL is a constant declared earlier as public static String MYCHANNEL = "com.sai.CHANNELONE";
If the caller does not pass a channel name, the default one declared would be used.
While joining a channel, we need to pass the Channel name and also an associated listener that is of the type IChordChannelListener.
So next step would be implement this listener.
Note the leave channel code would be like this:
public voidleaveChannel() {
mChord.leaveChannel(mPrivateChannelName);
mPrivateChannelName = "";
}
Step 3: Implement the IChordChannelListener.
All the 9 methods of this have to be implemented. These are the methods that would be called back when a file is sent or data is received etc. And the actual implementation for this would be in the Activity that is invoking the ChordManager service.
Here, based on the example from Samsung, I have also implemented these methods mainly as a way of calling a listener that is implemented by the activity invoking it.
@Override
public void onDataReceived(String arg0, String arg1, String arg2,
byte[][] arg3) {
if (!CHORD_APITEST_MESSAGE_TYPE.equals(payloadType))
return;
byte[] buf = payload[0];
if (null != mListener)
mListener.onReceiveMessage(fromNode, fromChannel, new String(buf));
}
@Override
public void onFileChunkReceived(String fromNode, String fromChannel, String fileName,
String hash, String fileType, String exchangeId, long fileSize, long offset) {
if (null != mListener) {
int progress = (int)(offset * 100 / fileSize);
mListener.onFileProgress(false, fromNode, fromChannel, progress, exchangeId);
}
}
@Override
public void onFileChunkSent(String toNode, String toChannel, String fileName,
String hash, String fileType, String exchangeId, long fileSize, long offset,
long chunckSize) {
if (null != mListener) {
int progress = (int)(offset * 100 / fileSize);
mListener.onFileProgress(true, toNode, toChannel, progress, exchangeId);
}
}
@Override
public void onFileFailed(String node, String channel, String fileName,
String hash, String exchangeId, int reason) {
switch (reason) {
case ERROR_FILE_REJECTED: {
if (null != mListener) {
mListener.onFileCompleted(IChordServiceListener.REJECTED, node, channel,
exchangeId, fileName);
}
break;
}
case ERROR_FILE_CANCELED: {
if (null != mListener) {
mListener.onFileCompleted(IChordServiceListener.CANCELLED, node, channel,
exchangeId, fileName);
}
break;
}
case ERROR_FILE_CREATE_FAILED:
case ERROR_FILE_NO_RESOURCE:
default:
if (null != mListener) {
mListener.onFileCompleted(IChordServiceListener.FAILED, node, channel,
exchangeId, fileName);
}
break;
}
}
@Override
public void onFileReceived(String fromNode, String fromChannel, String fileName,
String hash, String fileType, String exchangeId, long fileSize, String tmpFilePath) {
String savedName = fileName;
int i = savedName.lastIndexOf(".");
String name = savedName.substring(0, i);
String ext = savedName.substring(i);
Log.d("CHORDSERVICE", "onFileReceived : " + fileName);
Log.d("CHORDSERVICE", "onFileReceived : " + name + " " + ext);
File targetFile = new File(chordFilePath, savedName);
int index = 0;
while(targetFile.exists()) {
savedName = name + "_" + index + ext;
targetFile = new File(chordFilePath, savedName);
index++;
Log.d("CHORDSERVICE", "onFileReceived : " + savedName);
}
File srcFile = new File(tmpFilePath);
srcFile.renameTo(targetFile);
if (null != mListener) {
mListener.onFileCompleted(IChordServiceListener.RECEIVED, fromNode, fromChannel,
exchangeId, savedName);
}
}
@Override
public void onFileSent(String toNode, String toChannel, String fileName,
String hash, String fileType, String exchangeId) {
if (null != mListener) {
mListener.onFileCompleted(IChordServiceListener.SENT, toNode, toChannel,
exchangeId, fileName);
}
}
@Override
public void onFileWillReceive(String fromNode, String fromChannel, String fileName,
String hash, String fileType, String exchangeId, long fileSize) {
File targetdir = new File(chordFilePath);
if(!targetdir.exists()) {
targetdir.mkdirs();
}
//verifying if the external storage is avaiable
StatFs stat = new StatFs(chordFilePath);
long blockSize = stat.getBlockSize();
long totalBlocks = stat.getAvailableBlocks();
longavailableMemory = blockSize * totalBlocks;
if(availableMemory < fileSize) {
rejectFile(fromChannel, exchangeId);
if (null != mListener)
mListener.onFileCompleted(IChordServiceListener.FAILED, fromNode, fromChannel,
exchangeId, fileName);
return;
}
if (null != mListener)
mListener.onFileWillReceive(fromNode, fromChannel, fileName, exchangeId);
}
//This is called whenever a node joins a channel
@Override
public void onNodeJoined(String fromNode, String fromChannel) {
Log.v("CHORDSERVICE", "onNodeJoined(), fromNode : " + fromNode + ", fromChannel : "
+ fromChannel);
if (null != mListener)
mListener.onNodeEvent(fromNode, fromChannel, true);
}
//This is called whenever a node leaves the channel
@Override
public void onNodeLeft(String fromNode, String fromChannel) {
Log.v("CHORDSERVICE", "onNodeJoined(), fromNode : " + fromNode + ", fromChannel : "
+ fromChannel);
if (null != mListener)
mListener.onNodeEvent(fromNode, fromChannel, false);
}
};
Step 4: What should happen when a Node joins the channel and leaves the channel is also dictated by the methods overridden above.
In all of the above, you see that the Listener (a new one declared in the Service class) is what is passed in by the activity.
i.e. in the ChordService class, I have declared a new Listener – IChordServiceListener. And what does the listener do? It declares methods that the activity that called the ChordService should implement. They are related what should the activity do on receiving a message, when a node joins or leaves, when a network state changes etc.
So, IChordServiceListener is becoming the glue between the implementation in the activity and the call back methods with the ChordService to the IChordChannelListener.
Here is IChordServiceListener declaration:
public interfaceIChordServiceListener {
voidonReceiveMessage(String node, String channel, String message);
voidonFileWillReceive(String node, String channel, String fileName, String exchangeId);
voidonFileProgress(boolean bSend, String node, String channel, int progress,
String exchangeId);
public static final int SENT = 0;
public static final int RECEIVED = 1;
public static final int CANCELLED = 2;
public static final int REJECTED = 3;
public static final int FAILED = 4;
voidonFileCompleted(int reason, String node, String channel, String exchangeId,
String fileName);
voidonNodeEvent(String node, String channel, boolean bJoined);
voidonNetworkDisconnected();
void onUpdateNodeInfo(String nodeName, String ipAddress);
voidonConnectivityChanged();
}
Step 5: Now that we have implemented the IChordChannelListener, we have 2 more Listeners that we need to deal with. One is the INetworkListener.
This is implemented in the initialize method itself as follows:
mChord.setNetworkListener(new INetworkListener() {
@Override
public void onConnected(int interfaceType) {
if (null != mListener) {
mListener.onConnectivityChanged();
}
}
@Override
public void onDisconnected(int interfaceType) {
if (null != mListener) {
mListener.onConnectivityChanged();
}
}
});
Step 6: The only other listener we need to Implement is the IChordManagerListener. This is typically used by the ChordManager when it starts. Here is the implementation for the same.
public int start() {
return mChord.start(ChordManager.INTERFACE_TYPE_WIFI, new IChordManagerListener() {
@Override
public void onError(int arg0) {
}
@Override
public void onNetworkDisconnected() {
if (null != mListener)
mListener.onNetworkDisconnected();
}
@Override
public void onStarted(String name, int reason) {
if (null != mListener)
mListener.onUpdateNodeInfo(name, mChord.getIp());
if (STARTED_BY_RECONNECTION == reason) {
return;
}
IChordChannel channel= mChord.joinChannel(ChordManager.PUBLIC_CHANNEL,
mChannelListener);
}
});
}
Note that I have made an assumption that the ChordManager is going to use only Wifi as the mode of communication between nodes for simplicity sake.
With most of the above code , the basic aspects of the ChordService are ready for being invoked by any calling activity. There are a few aspects around binding to a service, unbinding to a service etc. I have in the code but not explaining here as it is not an aspect of the Chord Android SDK. It is more of a basic android service.
The complete code for this along with the activity that invokes the ChordService will be part of the next article in the series.
So, with all this basic exploration, I am curious to know if any of you have entered the Samsung Android Contest and also to see the plethora of ways this SDKhas been used innovatively.
