This is in continuation from my
previous post. Samsung’s latest devices (Samsung Galaxy
Note 3 and the Galaxy
Note 10.1 (2014 edition) tablet) are unique with the introduction of the S
Pen. The focus of the Samsung
SmartApp Challenge that is currently open expects developers to use the pen and the look packages
that are part of the Samsung
Mobile SDK briefed in my earlier two posts.
In this post I would like to dive a bit
deeper on the pen
package and in a subsequent post on the look package.
We will see what are they, as we go along.
S Pen is opening up a new horizon to
Smartphones that support it. In fact I would not be surprised if Samsung soon
open sources this project for encouraging wider adoption.
First, what is an S Pen?
Note that S Pen is an innovative
stylus-type input device that comes with the Galaxy Note range of devices. It
seems to have started off with the idea of making drawing or writing easy on
smartphone where a finger touch doesn’t provide a great experience. It is not a
capacitive stylus that typically phones came with but uses the Wacom’s EMR
(Electro-Magnetic Resonance) patented Technology. For more on the technology
behind the S Pen, you can read this article on
the XDA Developers Forum or the ‘Android
Authority’ post.
The tip of an S Pen allows for its usage in
apps that need sensitivity to pressure applied and precision. The side buttons
provide for press and release events based on which actions can be initiated.
In order to support developers to build
apps for the S Pen, a pen package has
been introduced as part of the Samsung Mobile SDK.
Next, what is the Pen package?
It is a package that allows developers to
write applications that can take hand-written inputs. It allows the use of a
pen, finger or any other kind of input tools or virtual pens to aid precise
user input in the most natural way possible. It feels like you are actually
writing or drawing on the device and would you call that a luxury? I am sure it
is an understatement for thos who use their devices extensively for all day to
day activities. J
The pen package
enables to
- · Draw using a pen/finger
- · Change user preferences for pens, erasers and text
- · Edit and save the inputs
- · Undo or redo thus managing history of inputs
- · Support both touch and hover events
A few words about the architecture of the pen package before
we look at snippets of program using the package:
As you can see the pen package is a
layer over the Android platform using
which many applications can be developed like the S-Note or S-Planner etc.
The pen
core is organized into various packages with clear separation of
responsibilities. The relevant methods
that can be used to develop apps have been made ‘public’ through what is shown
as the ‘Pen API’. It also provides a whole host of listeners
that help in handling the touch, the hover, the zoom, the long press, the
replay and the text change actions, to name a few.
The Engine
provides the core of the package. It a way of managing the runtime objects and
extensions to the Android view, line a canvas, text area, multi view, a context
menu etc., that can take in inputs from the pen or a finger.
The Model
module is literally the model of the pen package. It gives APIs to save a pen document and
retrieve it. It could be a note that is
to be saved and retrieved or a page with a set of strokes to be maintained in
the history or even a image, a stroke or a text box with support for all text
formatting – these could be persisted and retrieved.
The Setting
module is one that helps in understand whether the device support s pen
and manage the settings on the pen, eraser and text - a small utility package.
The UI
Control module consists of the various classes that help in managing the UI layouts
and associated context menu.
The Plug-in
module has a recognition class that allows for signature, text, shape and
equation recognition that can be used for very interesting apps. The S pen
Object Runtime allows developers to embed video clips or special text box as
sandbox.
In order to start developing using the pen package, you
need to download the Samsung Mobile SDK. It looks like that the programs need
to be tested on a real device and are not supported on an emulator. I did try
enabling on the emulator as given in the article on ‘Testing
S Pen Apps on an Emulator’. However it seems that it works with what is
called the S Pen SDK and
not with the pen
package, which is the focus of the developer challenge.
Now, unzip the Mobile SDK and you will find
a folder by name libs. In libs, you find pen folder in which you have 2 jar
files – “pen-v1.0.0.jar” and “sdk-v1.0.0.jar”. Both of these need to be copied into your
Android project libs folder and you
are ready to create a pen based app.
You can start with a simple hello world
program:
In the onCreate()
method, you will have to check the support for the s pen feature first:
boolean isSpenFeatureEnabled = false;
Spen
spenPackage = new Spen();
try {
spenPackage.initialize(this);
isSpenFeatureEnabled = spenPackage.isFeatureEnabled(Spen.DEVICE_PEN);
} catch
(SsdkUnsupportedException e) {
//Handle the exception here
return;
} catch (Exception
e1) {
Toast.makeText(mContext, "Cannot initialize
Spen.",
Toast.LENGTH_SHORT).show();
e1.printStackTrace();
finish();
}
Once this basic and essential check is
done, let us create a SpenSurfaceView
and add it to a relative layout:
RelativeLayout
spenViewLayout =
(RelativeLayout) findViewById(R.id.spenViewLayout);
mSpenSurfaceView = new SpenSurfaceView(mContext);
if (mSpenSurfaceView == null) {
Toast.makeText(mContext, "Cannot create new
SpenView.",
Toast.LENGTH_SHORT).show();
finish();
}
spenViewLayout.addView(mSpenSurfaceView);
The next thing you need to do is a SpenNoteDoc which holds a SpenPageDoc within it and voila, you are
ready with the first Spen app J
Display display = getWindowManager().getDefaultDisplay();
Rect rect = new Rect();
display.getRectSize(rect);
try {
mSpenNoteDoc =
new SpenNoteDoc(mContext, rect.width(), rect.height());
} catch (IOException
e) {
Toast.makeText(mContext, "Cannot create new
NoteDoc.",
Toast.LENGTH_SHORT).show();
e.printStackTrace();
finish();
} catch (Exception e)
{
e.printStackTrace();
finish();
}
mSpenPageDoc = mSpenNoteDoc.appendPage();
mSpenPageDoc.setBackgroundColor(0xFFD6E6F5);
mSpenPageDoc.clearHistory();
mSpenSurfaceView.setPageDoc(mSpenPageDoc, true);
Note that when you create a SpenNotedoc, you make it as big as the
display size that is available.
Then you create a SpenPageDoc and append it to SpenNoteDoc
and could optional set parameters like the background and clear the history, if
any.
And finally in the onDestroy() method ensure that you clean up after yourself as
shown:
protected void onDestroy() {
super.onDestroy();
if(mSpenSurfaceView != null) {
mSpenSurfaceView.close();
mSpenSurfaceView = null;
}
if(mSpenNoteDoc != null) {
try {
mSpenNoteDoc.close();
} catch (Exception e)
{
e.printStackTrace();
}
mSpenNoteDoc = null;
}
};
And you are done!! With this you have created the first pen app
with a canvas that takes the written input from a pen or a finger J
