Zana Bazid

Get the list of activities/applications installed on Android

2011-07-26T23:28:00.001-07:00

Following is the code to get the list of activities/applications installed on Android :
final Intent mainIntent = new Intent(Intent.ACTION_MAIN, null);
mainIntent.addCategory(Intent.CATEGORY_LAUNCHER);
final List pkgAppsList = context.getPackageManager().queryIntentActivities( mainIntent, 0);

You will get all the necessary data in the ResolveInfo to start a application. You can check ResolveInfo javadoc here.

Here's a cleaner way using the packageManager
final PackageManager pm = getPackageManager();
//get a list of installed apps.
List<ApplicationInfo> packages = pm
.getInstalledApplications(PackageManager.GET_META_DATA);

for (ApplicationInfo packageInfo : packages) {

Log.d(TAG, "Installed package :" + packageInfo.packageName);
Log.d(TAG,
"Launch Activity :"
+ pm.getLaunchIntentForPackage(packageInfo.packageName));

}// the getLaunchIntentForPackage returns an intent that you can use with startActivity()
}

More info here http://qtcstation.com/2011/02/how-to-launch-another-app-from-your-app/

To filter on sytem based apps :
private boolean isSystemPackage(ResolveInfo ri){
return ((ri.activityInfo.applicationInfo.flags&ApplicationInfo.FLAG_SYSTEM)!=0)?true:false;

}

private List<String> getInstalledComponentList() {
Intent componentSearchIntent = new Intent();
componentSearchIntent.addCategory(Constants.COMPONENTS_INTENT_CATEGORY);
componentSearchIntent.setAction(Constants.COMPONENTS_INTENT_ACTION_DEFAULT);
List<ResolveInfo> ril = getPackageManager().queryIntentActivities(componentSearchIntent, PackageManager.MATCH_DEFAULT_ONLY);
List<String> componentList = new ArrayList<String>();
Log.d(LOG_TAG, "Search for installed components found " + ril.size() + " matches.");
for (ResolveInfo ri : ril) {
if (ri.activityInfo != null) {
componentList.add(ri.activityInfo.packageName);// + ri.activityInfo.name);
Log.d(LOG_TAG, "Found installed: " + componentList.get(componentList.size()-1));
}
}
return componentList;
}

How to Build Funambol

2011-07-25T11:01:00.000-07:00

Your trail:

HOWTOBuildCapri

THIS PAGE IS OBSOLETE

Don't use it

Please refer to https://core.forge.funambol.org/wiki/BuildingFunambolV7

Introduction

Funambol is migrating all its components (at least when possible) to the Maven building system. You need to be familiar with Maven and its basic concepts in order to fully understand the below steps. You can find more information about Maven in the resource section.Thanks to maven, you do not usually have to worry about CVS and CVS tags (or SVN) in order to work with Funambol. You just need to know which components you need and which version. You do not even have to know how to download the components you need, once you have configured Maven, it will do all the magic for you. All components binaries are published on a public maven repository athttp://m2.funambol.com/repositories, which is where maven will download everything it requires.
As a result of this new build structure, you will be able to package a Funambol distribution without the need of a single line of code. This allows us to decouple the development-compile-test process from the building of a distributable package. It is much easier, for example, set up a continuous integration server that builds nightly all components and make them available on a repository. Then you can easily have a separate packaging process that builds a distributable package containing a subset of the released components.
One of the biggest advantages of this approach is that if you are a developer of a specific component, for example the foundation module, you do not need to know how to build the entire CVS tree to work. You just checkout the component work on it, publish your artifact and you are done.
This document describe how to package a Funambol distribution first, and then how to build the source code.
Note that at the time of writing Ant is still required for some components or as a glue multi-platform scripting language.

Prerequisites

Before moving on, make sure the following pre-requirements are installed in your environment.

J2SE 1.5. See its documentation for details about installation.
Ant 1.6.5
Maven 2.0.9
Netbeans 5.5 platform: download the zip file and unpackage it where you want (we will refer to this directory with<NETBEAN_PLATFORM>)
Apache Tomcat 6.0.16: download apache-tomcat-6.0.16.zip and save it in <TOOLS>
Hypersonic DB 1.8.0: download hsqldb_1_8_0_7.zip (or newer) and save it in <TOOLS>
NSIS 2.2x: download the exe file and install it where you want (we will refer to this directory with <NSIS>). You should also install theInetc plug-in copying inetc.dll in <NSIS>\plugin.

Setting up the environment

Your building environment needs some customization.

Setting up Ant

Copy the following jars $ANT_HOME/lib (those files enable ant for scripting and for maven tasks):

Configuring maven

Maven must be configured with the Funambol maven repository. Add the following section to the active maven profile (in $HOME/.m2/settings.xmlor C:\Documents and Settings\<username>\.m2):

<repositories>
  <repository>
    <id>artifacts</id>
    <url>http://m2.funambol.org/repositories/artifacts</url>
  </repository>
  <repository>
    <id>snapshots</id>
    <url>http://m2.funambol.org/repositories/snapshots</url>
  </repository>
</repositories>
<pluginRepositories>
  <pluginRepository>
    <id>artifacts</id>
    <url>http://m2.funambol.org/repositories/artifacts</url>
  </pluginRepository>
  <pluginRepository>
    <id>snapshots</id>
    <url>http://m2.funambol.org/repositories/snapshots</url>
  </pluginRepository>
</pluginRepositories>

See settings.xml for an example.

Preparing JRE zip file for Windows system

Note that this JRE will be included in the bundle and in the Administration Tool for Windows system so if you are not interested on those you can skip this step.

Download JRE 1.5.0_xx from SUN website and install it in <JRE>.
Zip <JRE> in a file with name jre1.5.0_xx.zip.

This zip file should contain:

jre1.5.0_xx
      bin
      ...
      lib
      ...

Copy the file jre1.5.0_xx.zip in <TOOLS>.

Getting JRE for Linux system

Note that this JRE will be included in the bundle for Linux system so if you are not interested on that you can skip this step.Download jre-1_5_0_xx-linux-i586.bin from SUN website and save it in <TOOLS>.

Getting Funambol sources

In order to get the sources, execute the following commands:cvs -d:pserver:anonymous@cvs.forge.objectweb.org:/cvsroot/sync4j login cvs -z3 -d:pserver:anonymous@cvs.forge.objectweb.org:/cvsroot/sync4j co capri
when a password is asked during login command, press Enter. This will checkout the source code in <capri> directory.
In order to checkout a specific release, you should checkout the code using the wanted tag:
cvs -d:pserver:anonymous@cvs.forge.objectweb.org:/cvsroot/sync4j login cvs -z3 -d:pserver:anonymous@cvs.forge.objectweb.org:/cvsroot/sync4j co -r tag capri

Configuring the environment

Edit <capri>/forge/build.properties changing the following properties:

nbplatform.default.netbeans.dest.dir=<NETBEAN_PLATFORM>
tomcat.pkg=<TOOLS>/apache-tomcat-6.0.16.zip
tomcat.name=apache-tomcat-6.0.16
hsqldb.pkg=<TOOLS>/hsqldb_1_8_0_7.zip
hsqldb.name=hsqldb

On Windows system:

jre.pkg=<TOOLS>/jre1.5.0_xx.zip
nsis.home=<NSIS>

On Linux system:

jre.pkg=<TOOLS>/jre-1_5_0_xx-linux-i586.bin
jre.name=jre1.5.0_10

Edit <capri>/admin-suite/build.properties changing the following property:

nbplatform.default.netbeans.dest.dir=<NETBEAN_PLATFORM>

On Windows system:

nsis.home=<NSIS>

Build the bundle

Move under <capri>/forge and run one between the following commands depending on what you want to forge/build:

ant forge-bundle-win: forge the bundle for Windows system
ant forge-bundle-unix: forge the bundle for Unix/Linux system

Build the Administration tool

If you want to build only the Administration tool, you should download just its code executing the following commands:cvs -d:pserver:anonymous@cvs.forge.objectweb.org:/cvsroot/sync4j login cvs -z3 -d:pserver:anonymous@cvs.forge.objectweb.org:/cvsroot/sync4j co 3x/admin-suite
(remember to specify a tag if you want to build a specific version).
Edit admin-suite/build.properties changing the following property:

nbplatform.default.netbeans.dest.dir=<NETBEAN_PLATFORM>

On Windows system:

nsis.home=<NSIS>
jre.pkg=<TOOLS>/jre1.5.0_xx.zip (this property is missing in the build.properties file and must be added)

Then simply move in 3x/admin-suite and run:

ant forge-admin-unix: forge the tgz version
ant forge-admin-win: forge the exe version for windows

In the target directory you should find the packages.

Build the iPod plugin

If you want to build only the iPod plugin, you should download just its code executing the following commands:cvs -d:pserver:anonymous@cvs.forge.objectweb.org:/cvsroot/sync4j login cvs -z3 -d:pserver:anonymous@cvs.forge.objectweb.org:/cvsroot/sync4j co funambol/clients/ipod
(remember to specify a tag if you want to build a specific version).
then simply move in funambol/clients/ipod directory and run:

mvn package: forge the tgz version
mvn package exec:exec: forge the exe version for windows

In the target directory you should find the packages.

Build the SDK

If you want to build only the SDK, you should download just its code executing the following commands:cvs -d:pserver:anonymous@cvs.forge.objectweb.org:/cvsroot/sync4j login cvs -z3 -d:pserver:anonymous@cvs.forge.objectweb.org:/cvsroot/sync4j co funambol/sdk
(remember to specify a tag if you want to build a specific version).
then simply move in funambol/sdk directory and run:

mvn package

In the target directory you should find the packages.

Build ALL

For convenience, a script to build all components respecting the dependencies order is available. Check out all the required source code executing the following commands:cvs -d:pserver:anonymous@cvs.forge.objectweb.org:/cvsroot/sync4j login cvs -z3 -d:pserver:anonymous@cvs.forge.objectweb.org:/cvsroot/sync4j co capri-server
(remember to specify a tag if you want to build a specific version).
Configure capri-server/forge/build.properties and capri-server/admin-suite/build.properties as previously specified
Move in capri-server/forge and run:

ant forge-all

Resources

Maven resources

Funambol m2 Repo

2011-07-25T10:43:00.000-07:00

Analysis and Comparison with Android and iPhone Operating System

2011-07-24T03:08:00.000-07:00

Lu Cheng
1 System Development History
1.1 History of Android
Android is not only a mobile operating system that uses a modified version of the Linux kernel [1][2][3],
but also a software stack for mobile devices that includes an operating system, middleware and key
applications.
In July 2005, Google bought Android, Inc., a tiny startup company based in Palo Alto, California, USA. At
Google, the team led by Rubin developed a mobile device platform powered by the Linux kernel and their
main marketing targets were hardware component and software partners with an easy and flexible
operating system. On the November 5th in 2007, several companies including Google, HTC, Motorola,
Intel and so on came together to form the Open Handset Alliance and stated the goal for developing open
standards for mobile devices, meanwhile unveiled the new product: Android, a mobile device platform
built on the Linux kernel version 2.6[4]. Android has been available as open-source software since October
2008. Under the Apache License, private companies could add on their own applications and extensions
and sell them, without having to submit them to the open-source community [5]. Since its original release,
Android has seen a number of updates with fixed bugs and new features. Cupcake (the official 1.5 update),
which based on Linux kernel 2.6.27 was released on 30 April 2009. Cupcake improves the ability to record
and watch videos with the camcorder mode and enable uploading videos to YouTube and pictures to
Picasa directly from the phone. The Cupcake also supports Bluetooth A2DP and can connect to a
Bluetooth headset within a certain distance. On 15 September 2009, Donut (the 1.6 SDK) was released.
Donut improved Android Market experience and provides an integrated camera, camcorder and gallery
interface. It also updated Voice Search to have a faster response time deeper integration with native
applications. Search experience and technology support are also updated. The updated version 2.0, Eclair
was released on 26 October 2009. It optimized the hardware speed and support for more screen sizes and
resolutions. Eclair introduced new browser UI and new contact lists, and provides better white/black ratio
for backgrounds. Besides, it built in flash support for Camera and enables the digital zoom. The
subsequent version 2.1 is named FroYo and the next update after FroYo will be called Ginerbread.

1.2 History of iPhone

iPhone operating system is a mobile operating system developed and marketed by Apple Inc. It is the

default operating system for the iPhone, the iTouch and the iPad. The iPhone OS was derived from Mac

OX X and the version history of iPhone OS began at June 29, 2007 with the release of the iPhone [6].

iPhone OS had no official name until the first beta version of the iPhone SDK released in March 6, 2008.

Before then, Apple marketing literature simply stated the iPhone uses OS X. The initial version of iPhone

was released on June 29, 2007. The version 1.0.2 was initially released on iPod Touch on September 14,

2007. Version 1.1.1 updated the interface for the calculator application, supported the TV out and

provided adjustable volume and louder speakerphone. Later the version 1.1.2 was released on November

12, 2007. It provides the battery charge level indicator and international language & keyboard

support. Version 1.1.3 provides more feature then previous versions. It added the mail, maps, stocks,

weather and notes applications for iPod touch, enable lyrics support for music and chapter support for

movies. Besides, it increased the SMS storage capacity from 1,000 to 75,000 and gains the new feature on

Google Maps, the 'Locate Me' can determine the phone's approximate location. Version 1.1.4 and 1.1.5

was released on February 26, 2008 and July 15, 2008 respectively. They fixed bugs and improve the speed

of interface. The version 2.0 was available with the release of the iPhone 3G on July 11, 2008. It enhanced

the operating system, making it able to turn Wi-Fi back on in Airplane mode and support SVG and Cisco

IPsec VPN. 2.0 also enhance the language by providing extra keyboard languages and support the

traditional and simplified Chinese handwriting recognition. On September 9, 2008, Apple Inc. released the

version 2.1. It fixes the bugs and enhances the system performance. It provides new OS features like

changed 3G, EDGE and GPRS indicators, turn off the camera within the restrictions page. Besides, version

2.1 provides the new application features like more information within iPod music lists and audiobooks.

The version 2.2 which released on November 21, 2008 enhances the performance on maps and mail,

improved the stability and performance of Safari. It also improved the performance on many aspects like

the sound quality of visual voicemail message and so on. On June 17, 2009, Apple Inc. released the version

3.0 with the iPhone 3GS. Current version is 3.2 which published on January 27, 2010. It supports the newly

announced iPad and the landscape springboards, added terrain view in maps application.

2 System Architecture

2.1 Android Architecture

The Android architecture has several layers as showed in Figure 1.

Kernel: Linux is support for core system services such as security, memory management, process

management, network stack, and driver model [7]. The kernel also acts as an abstraction layer between

the hardware and the rest of the software stack.

Figure 1. Android Architecture

Runtime: Runtime includes core libraries and Dalvik virtual machine. Core libraries have a set of core

libraries that provides most of the functionality available in the core libraries of the Java programming

language. Every Android application runs in its own process, with its own instance of the Dalvik virtual

machine. The Dalvik VM executes files in the Dalvik Executable (.dex) format which is optimized for

minimal memory footprint. The VM is register-based, and runs classes compiled by a Java language

compiler that have been transformed into the .dex format by the included "dx" tool. The Dalvik VM relies

on the Linux kernel for underlying functionality such as threading and low-level memory management.

Libraries: Android has a set of C/C++ libraries used by various components of the Android system. These

libraries are exposed to developers. The system C library is a BSD-derived implementation of the standard

C system library. The media libraries are based on PacketVideo’s openCORE which support playback and

recording of many popular audio formats. The surface manager manages access to the display subsystem

and seamlessly composites 2D and 3D graphic layers from multiple applications.

Application Framework: All Android applications are written with Java programming language, it ships

with a set of core applications including email client, SMS program, calendar, maps, browser, contacts and

others. Android offers developers the ability to build various applications with an open development.

Developers have full access to the same framework APIs used by the core applications. The application

architecture is designed to simplify the reuse of components; any application can publish its capabilities

and any other application may then make use of those capabilities. This same mechanism allows

components to be replaced by the user. The applications including views that can be used to build an

applications, including lists, grids, text boxes, buttons, and even an embeddable web browser. Content

providers enable applications to access data from other applications or to share data with others. The

resource manager providing access to non-code resources such as localized strings, graphics and layout

files. The notification manager enable all applications to display custom alter in the status bar. The activity

manager manages the lifecycle of applications and provides a common navigation backstack.

2.2 iPhone Architecture

Figure 2. iPhone Architecture

Hardware: In iPhone, Hardware refers to the physical chips soldered to the iPhone’s circuitry. The actual

processor falls under this layer, but the instruction set and in-memory descriptor tables are contained

within the “processor” layer.

Firmware: Firmware refers the chip-specific code that is either contained with memory in/around the

peripheral itself, or within the drive for said peripheral.

Processor: Processor is refers to the ARM instruction set and the interrupt descriptor table as set up by

the iPhone OS during boot and driver initialization.

iPhone OS: iPhone OS is the kernel, drivers, and services that comprise of the iPhone Operating System. It

sits between the user space and hardware.

Objective-C Runtimes: Objective-C runtime is comprised of both the Objective-C dynamically-linked

runtime libraries, as well as the underlying C libraries.

Frameworks/API: Frameworks/API layer has API calls which are Apple-distributed headers with the iPhone

SDK, with some dynamic linking occurring at runtime. These reside on top of the Objective-C runtime, as

many of these are written in Objective-C.

Application: The application stored in iPhone has to be purchased through the application store. This

application was compiled to native code by the Apple-distributed iPhone compiler, and linked with the

Objective-C runtime and C library by the linker. The application also runs entirely within the user space

environment set up by the iPhone OS.

3 Hardware

3.1 Android

Android is used as mobile operating system for many mobile phones, like Motorola CLIQ, Samsung Behold

and so on. DROID by Motorola adopt Android 2.0 as the operating system.

Processor: process in DROID is Arm® CortexTM A8 which based on the ARMv7 architecture with the speed

of 550 mHz. The high-performance of Arm® CortexTM A8 processor is proven in end devices today as it can

meet the requirements for power-optimized mobile devices needing operation in less than 300mW.

Memory and secondary storage: The Motorola Droid has only 256MB of memory on which it can store

applications and it cannot run applications off the SD Card. The secondary memory for music, image and

general storage installed in DROID is 16 GB microSD, a removable flash memory cards. It also can support

up to 32 GB microSD.

Camera: The camera with automatic focus and dual led has 5 MP megapixels and 4x digital zoom, it has

the features like image stabilization, real-time color effects, scene modes and location tagging.

Sensor: The sensor in DROID has proximity, ambient light and eCompass.

Screen: The screen is 3.7 inch with 16:9 widescreen with TFT display type.

Battery: The DROID uses 1400 Ah Li Ion battery with up to 270 hours standby time, the continuous usage

time is up to 358 minutes.

Media and Network: The DROID has the audio and video streaming media and supports multiple video

formats like AAC, MP3, WAV, MIDI and so on. It supports Wi-Fi and Bluetooth, the GPS provides the

service like aGPS, sGPS, Google maps, eCompass.

3.2 iPhone

The iPhone operating system is used on iPhon3, iTouch and iPad.

Processor: Samsung S5PC100 (ARM Cortex A8 @ 600 MHz. The processor in the 3GS at 600 MHz is 1.5x

faster in terms of raw MHz, but it’s based on the Cortex A8 which uses the more advanced ARM v7

architecture versus the 3G model at ARM v6[10].

Memory and secondary storage: The memory in iPhone is only 128MB, but it supports 8GB second

storage for general storage.

Screen: The screen in iPhone is a 9 cm liquid crystal display with scratch-resistant glass and 18-bit color.

The touch screen has multi-touch sensing and its touch and gesture features are based on technology

developed by FingerWorks [9].

Sensor: The iPhone has three sensors, proximity sensor deactivates the display and touch screen, it save

the battery power and prevent inadvertent inputs. The ambient light sensor adjusts the display

brightness and hence also saves the battery power. The 3-axis accelerometer sensor senses the

orientation of the phone and changes the screen accordingly. Plus, moisture sensor installed in iPhone is

capable to detect whether the device has been affected or damaged by water.

Media and network: The audio processing plug-ins, known as audio units, can be dynamically accessed

from the user’s iPhone OS application. It allows user to add a variety of useful, prepackaged audio

features and take advantage of the low latency that audio units offer. iPhone OS ships with audio units

that support mixing, equalization, format conversion, and I/O for recording, playback, or live chat. The

built-in Bluetooth 2.x + EDR support the wireless earpieces and headphones. Stereo audio was added in

the 3.0 update for hardware that supports A2DP. With these profiles, iPhone can exchange multimedia

files like pictures, music and video, with other Bluetooth enabled cell phones

Battery: iPhone has an internal rechargeable battery which is not user-replaceable. The battery can be

charged when connect the iPhone to a computer via USB to dock connector cable. The official report from

Apple's website says that the battery life is designed to retain up to 80% of its original capacity after 400

full charge and discharge cycles. The iPhone's battery is capable of providing up to 250 hours standby, 24

hours of music, seven hours of video, six hours of web browsing and eight hours of talk time.

Camera: iPhone has a built-in fixed focus 2.0 megapixel camera located on the back for digital photos. The

camera has no optical zoom, flash or auto-focus, and does not supporting video recording neither. iPhone

3GS has a 3.2 megapixel camera which supports auto focus, auto white balance and video recording. The

video can be uploaded to YouTube or other services directly.

4 System management

4.1 Thread management

Android

When the first of an application's components needs to be run, Android starts UI thread, a Linux process

for it with a single thread of execution. The UI thread, which also know as main thread is automatically

created when an Android application is started. UI thread is very important because it takes in charge of

dispatching the event to the appropriate widgets. UI thread also the thread people interact with the

Android widgets. When people touches a button, the UI thread will dispatches the touch event to the

widget which in turn sets its pressed state and posts an invalidate request to the event queue. It

dequeues the request and notifies the widget to redraw itself. By default, all components of the

application run in that process and thread. Each component is run by a process, and the component

elements have a process attribute which specify the process where the component should run. By setting

bthe attributes in different way, it is easy to know whether the component run in its own process or share

a process with other components. No component should perform long operation when called by the

system in order not to block other components which also in the process. Besides, when the memory is

low and other processes have more immediately requirement, the Android will decide to shut down a

process. The application components running in that process will be destroyed consequently. Therefore,

android weights the importance of each thread to the user to decide the victim.

Android provides Handler and Looper to manage threads and let them communicate with each other.

Looper is used for running a message loop within a thread, headler is processing the messages and

HandlerThread is setting up a thread with a message loop. After a child thread create an image from the

web, it notifies the UI thread by sending a message using the handler that's bound to UI thread's message

queue. The data produced by the child process can also send via the message. Therefore, the UI thread

can update with the data produced by the child thread. When a Handler is created, it is bound to the

message queue of the thread that created it.

iPhone

In iPhone OS, each application is made up of one or more threads, which represents a single path of

execution. Every applications starts with a single thread, which runs the application's main function. The

applications can have additional threads with executes a specific function. When application generates a

new thread, it becomes an independent entity inside the process space. Each thread has its own

execution stack and the kernel schedules its run time separately. As threads are in the same process space,

they can communicate with other threads and processes. All threads in a single application share the

same virtual memory space and have the same access rights as the process itself. Each thread requires

the memory allocation in both the kernel memory space and the program memory space. The core

structures needed to manage the thread and coordinate its scheduling. The stack space of thread and the

per-thread data is stored in program's memory space. When first create the thread, the most of

structures are created and initialized. In order to creating the low-level thread, a function or method to

act as the main entry point for thread is needed, then one of the available thread routines has to be used

to start the thread. The thread can be created by using the different methods as using NSThread, POSIX

Threads, or using NSObjec to spawn a thread. After a thread is created, different thread environment

needed to be configured, like configuring the stack size of a thread and the thread-local storage, setting

the detached state of a thread and the thread priority.

4.2 Interrupt

An interrupt is an indication to a thread that it should stop what it is doing and do something else. It's up

to the programmer to decide exactly how a thread responds to an interrupt, but it is very common for the

thread to terminate.

a. Android

In Android, signal is a blocking I/O operation has been interrupted. The number of bytes that were

transferred successfully before the interruption took place is stored in a field of the exception. Lock

implementations provide more extensive locking operations than can be obtained using synchronized

methods and statements. They allow more flexible structuring, may have quite different properties, and

may support multiple associated Condition objects. As interruption generally implies cancellation, and

checks for interruption are often infrequent, an implementation can favor responding to an interrupt over

normal method return. This is true even if it can be shown that the interrupt occurred after another

action may have unblocked the thread. An implementation should document this behavior.

b.iPhone

Most device drivers never need to take primary interrupts because their interrupt lines don’t cascade into

the system’s interrupt controller. For example, FireWire and USB devices have a notion of interrupts, but

are really just messages on a serial bus. These are commonly referred to as software interrupts because

apart from the interrupt caused by the message itself, the interrupt is entirely simulated in software.

4.3 Inter-process communication

a. Android

In Abdroid’s computing, the Inter-process communication (IPC) is a set of techniques for the exchange of

data among multiple threads in one or more processes. Processes may be running on one or more

computers connected by a network. IPC techniques are divided into methods for message passing,

synchronization, shared memory, and remote procedure calls (RPC). The method of IPC used may vary

based on the bandwidth and latency of communication between the threads, and the type of data being

communicated.

b. iPhone

For iPhone, any time the sequence in which two operations are completed affects the result, there is the

potential for a race condition. For example, if two processes (in a single program or different programs)

share the same global variable, then there is the potential for one process to interfere with the other or

for an attacker to alter the variable after one process sets it but before the other reads it. The solution to

race conditions of this type is to use some locking mechanism to prevent one process from changing a

variable until another is finished with it. There are problems and hazards associated with such

mechanisms, and they must be implemented carefully.

4.4 System calls

A system call is a request made by any program to the operating system for performing tasks—picked

from a predefined set—which the said program does not have required permissions to execute in its own

flow of execution. System calls provide the interface between a process and the operating system.

a. Android

Developer can trace the system calls invoked by Android for specific tasks by Android Task. The developer

have to figure out which process is actually managing the data items, and then use strace <app name>

after start to strace an application. It can also attach to an existing process by using the command 'strace -

p <pid>'. Use 'ps' to find the process which is managing the contacts and messaging.

b.iPhone

The iPhone OS provides tools for system profiling. The Shark application lets user selectively find out what

file system-related function calls the application makes. When user set up the session configuration, he

can tell Shark exactly which function calls you want it to watch. A list of system calls includes all the file

I/O calls plus fcntl, flock, fstat, fsync, link, lstat, lstatv, and stat. The sc_usage tool displays an ongoing

sample of system statistics for a given process, including the number of system calls and page faults. The

tool adds new system calls to the list as they are generated by the application being watched. The counts

displayed are both the cumulative totals since sc_usage was launched and the delta changes for this

sample period.

4.5 Memory management

Memory management is the programming discipline of managing the life cycles of objects and freeing

them when they are no longer needed. Managing object memory is a matter of performance; if an

application doesn’t free unneeded objects, its memory footprint grows and performance suffers.

a. Android

Android applications usually are limited to 16 MB of heap. Though it is very little for some developers, it is

a lot of memory for a phone. Because the more applications Android can keep in memory, the faster it will

be when user switch between its applications. Therefore, the applications should use as little memory as

possible to guarantee multiple applications run without getting killed. The memory leak phenomenon

affects the memory usage, and hence affects the application switch efficiency. All Android apps are

written in Java. Java, unlike other programming languages, does not require any coding to allocate or

deallocate memory and handles all memory allocation/deallocation through a "feature" called automatic

garbage collection. The garbage collector kicks in whenever an application no longer has any active

threads pointing to it. By design, the garbage collector will not remove applications that are actively being

used; but there may be a bit of system degradation while things are being cleaned up (usually a very fast

process). Android rely on automatic memory management which handled by garbage collector. However,

the garbage collector can sometimes cause performance issues if memory allocation is not handled

carefully. The Android SDK provides allocation tracker, a tool to avoid the frequent garbage collection.

b.iPhone

iPhone has no garbage collection, developer has to clean up the variables after use them, otherwise the

program will leak memory. Though NSObject class has accounting stuff help to keeps the track of how

many other objects are currently using the object, but it is not automatic and developers have to adjust

that by themselves. The rule for managing memory is to make sure the number of ownership methods

called on an object will equal the number of loss-of-ownership methods by the time the program has

finished executing. When create or copy an object, its retain count is 1. Thereafter other objects may

express an ownership interest in your object, which increments it’s retain count. The owners of an object

may also relinquish their ownership interest in it, which decrements the retain count. When the retain

count becomes zero, the object is deallocated (destroyed).

4.5 Networking support

Wi-Fi: Wi-Fi is the IEEE 802.11 standard, is a two-way, short range protocol and operates in two bands.

Initially, all Wi-Fi used 2.412-2.472 GHz. The 802.11n protocol added the ability to use 5.15 to 5.25 GHz

(indoor use), but the iPhone is restricted to 802.11b/g. The networking stack in iPhone OS includes several

interfaces over the radio hardware of iPhone and iPod touch devices. The main programming interface is

the CFNetwork framework, which builds on top of BSD sockets and opaque types in the Core Foundation

framework to communicate with network entities. Android comes with a complete support for the Wi-Fi

connectivity. The main component is the system-provided WiFiManager. As usual, user obtain it via

getSystemServices() call to the current context. Once they have the WiFiManager, they can ask it for the

current Wi-Fi connection in form of WiFiInfo object. Also they can ask for all the currently available

networks via getConfiguredNetworks(). That gives the list of WifiConfigurations.The WiFiScanReceiver is

registered by WiFiDemo as a broadcast receiver to be invoked by the system when new Wi-Fi scan results

are available. WiFiScanReceiver gets the callback via onReceive(). It gets the new scan result from the

intent that activated it and compares it to the best known signal provider. It then outputs the new best

network via a Toast.

Bluetooth: Bluetooth is a two-way, ultra short range protocol that works in the 2.40-2.485 GHz band. It

avoids interference with other systems in the same band by being very low power, about a milliwatt, and

has a maximum range of about 10 meters. The Android platform includes support for the Bluetooth

network stack, which allows a device to wirelessly exchange data with other Bluetooth devices. The

application framework provides access to the Bluetooth functionality through the Android Bluetooth APIs.

These APIs let applications wirelessly connect to other Bluetooth devices, enabling point-to-point and

multipoint wireless features.

3G: iPhone 3G(S) is a "quad-band phone" which means it can also operate on the GSM 900 and GSM 1800

frequencies used in Europe. 3G technology gives iPhone fast access to the Internet and email over cellular

networks around the world. With support for 7.2Mbps HSDPA, iPhone 3GS also makes it possible to do

more in more places: Surf the web, download email, get directions, and watch video — even while user is

on a call. Since iPhone seamlessly switches between EDGE, faster 3G, and even faster Wi-Fi, user can

always get the fastest connection available. Users can even share their Internet connection with laptop

via Internet tethering.

4G: 4G refers to the fourth generation of cellular wireless standards. It is a successor to 3G and 2G

standards, with the aim to provide a wide range of data rates up to ultra-broadband (gigabit-speed)

Internet access to mobile as well as stationary users. Sprint openly confirsm plans to sell a 4G Android

smartphone next year. 4G aptly called MAGIC (Mobile multimedia, Anytime/any-where, Global mobility

support, Integrated wireless and Customized personal service) provides for data rates of up to more than

100Mbps for the mobile users. This WiMax-connected device will run three or five times faster than the

3G-connected iPhone (on a good day), and will feature a bunch of apps that fully exploit that speed.

Verizon Wireless said earlier this year that they see the Apple iPhone on their 4G network in 2010. A

rumor about Verizon and Apple already testing a new iPhone on the Verizon Wireless 4G LTE network

sneaked its way through the Motorola Droid coverage over the weekend.

4.6 Power Management

a.Android

Android supports its own Power Management (on top of the standard Linux Power Management)

designed with the premise that the CPU shouldn't consume power if no applications or services require

power. Android requires that applications and services request CPU resources with "wake locks" through

the Android application framework and native Linux libraries. If there are no active wake locks, Android

will shut down the CPU. The Android Framework exposes power management to services and applications

through the PowerManager class. User space native libraries should never call into Android Power

Management directly. Bypassing the power management policy in the Android runtime will destabilize the

system. All calls into Power Management should go through the Android runtime PowerManager APIs.

b.iPhone

iPhone do not have the power management toolkit as Mac OS does. Instead, this function is embedded

into the core layer, which intelligently powers up planes of devices as the system goes into standby or to

sleep. The most power hungry systems in iPhone from most to least are 3G radio system, Wi-Fi, 2G radio

system, Bluetooth and GPS. Reduce the number of power consuming applications helps to save the

energy. When put an iPhone into sleep, it will disconnect from network, turn off the Wi-Fi and screen

light.

4.7 Development kit

a.Android

The Android Software development kit includes a comprehensive set of development tools which include

debugger, libraries, documentation, sample codes and tutorials. The SDK support the development

platforms with x86-architecture computers running Linux, Mac OS X, Windows XP and Vista. The SDK also

requires to development environment have Java Development Kit, Apache Ant and Python. Eclipse with

Android Development Tools Plug-in is the official integrated development environment (IDE) for Android

SDK.

The Android 0.9 SDK beta was released on 18 August 2008. It provides an updated and extended API,

improved development tools and an updated design for the home screen. The version 1.0 Android SDK

was released on 23 September, it had fixed the main bugs and made several API changes from the 0.9

version. Google released the Android SDK version 1.1 on 9 March 2009. Version 1.1 includes the update

for supporting search by voice, priced applications, alarm clock fixes, fixes mail notification and so on. It

also made the update that the Dev phones can access paid applications and developers can see them on

the Android Market. The SDK versions 1.5 and 1.6 were released on May 2009 and September 2009

respectively. They support many new features like video recording, voice recognition, battery usage

indicator and VPN control applet.

b.iPhone

With this software the programmer can develop applications that run on iPhone and iPod touch, Including

the Xcode IDE, Instruments, iPhone simulator, frameworks and samples, compilers, Shark analysis tool,

and more. With over 1,000 new APIs, iPhone SDK provides developers with a range of new possibilities to

enhance the functionality of their applications. New APIs also provide support for applications to

communicate with hardware accessories attached to iPhone or iPod touch. The SDK requires an Intel Mac

running Mac OS S Leopard or later, other operating systems like Microsoft Windows and older version of

Mac OS X are not supported.

5 Comparison

5.1 Development Environments

The Android use java as develop language. With Android’s support for multiple processes and component

reuse, the platform itself provides support for Intents and Activities (an intent is just a variant of a

command) and provides a way of declaring user preferences in XML which is extensible allowing custom

UI components to be integrated. Android development leverages the excellent JDT tools, everything Java

is indexed, the IDE has a rich model of the source code, and refactoring is seamless. JDT's incremental

compiler provides immediate feedback with errors and warnings as you type. In Android, UI builder can’t

display UIs how they’ll actually appear.

iPhone uses Objective-C as its development language. Eclipse can be used as iPhone OS development IDE.

Beside, Aptana, a cross-platform IDE has released their iPhone Development Plug-in for their Ajax IDE. It

can preview pages in both horizontal and vertical mode, and includes a wizard for importing the most

common Ajax libraries. iPhone application developers are given a good UI builder; It’s flexible and can

model some sophisticated UIs, ease to port third party applications.

5.2 Reliability and Security

Android is a multi-process system, in which each application (and parts of the system) runs in its own

process. Most security between applications and the system is enforced at the process level through

standard Linux facilities, such as user and group IDs that are assigned to applications. Additional finer-

grained security features are provided through a "permission" mechanism that enforces restrictions on

the specific operations that a particular process can perform, and per-URI permissions for granting ad-hoc

access to specific pieces of data. As an open platform, Android allows users to load software from any

developer onto a device. As with a home PC, the user must be aware of who is providing the software

they are downloading and must decide whether they want to grant the application the capabilities it

requests. This decision can be informed by the user's judgment of the software developer's

trustworthiness, and where the software came from.

The iPhone has no security software and Apple doesn't let people load third-party programs on the device,

which could reduce the risk of infection from malicious software. When the iPhone is connected to the

Web, dangerous possibilities emerge. The iPhone Auto-Lock disables the device's screen after a preset

time period of non-use, and the Passcode Lock feature takes that a step further. Whenever the device's

display locks, whether due to Auto-Lock or because you've hit the iPhone Sleep button--found on the top

right of the device--Passcode Lock requires a four-digit code to be entered before the device can be

employed again. With the password failure actions, it’s possible to configure an iPhone to perform a soft

reset, lock the device, or wipe all the data after a pre-configured number of failed login attempts. If a user

forgets his or her password, the device can be unlocked using a remote unlock service. The iPhone OS

security APIs are located in the Core Services layer of the operating system and they are based on services

in the Core OS (kernel) layer of the operating system. Applications on the iPhone call the security services

APIs directly rather than going through the Cocoa Touch or Media layers. Networking applications can

also access secure networking functions through the CFNetwork API, which is also located in the Core

Services layer.

The iPhone OS security implementation includes a daemon called the Security Server that implements

several security protocols, such as access to keychain items and root certificate trust management. The

Security Server has no public API. Instead, applications use the Keychain Services API and the Certificate,

Key, and Trust services API, which in turn communicate with the Security Server. Because, unlike the Mac

OS X security services, the iPhone OS security services do not provide an authentication interface, there is

no need for the Security Server to have a user interface. Although Mac OS X includes a low-level

command-line interface to the OpenSSL open-source cryptography toolkit, this interface is not available

on the iPhone OS. For iPhone OS development, use the CFNetwork API for secure networking and the

Certificate, Key, and Trust Services API for cryptographic services.

5.3 Virtualization

Every Android application runs in its own process, with its own instance of the Dalvik virtual machine.

Dalvik has been written so that a device can run multiple VMs efficiently. The Dalvik VM executes files in

the Dalvik Executable (.dex) format which is optimized for minimal memory footprint. The VM is register-

based, and runs classes compiled by a Java language compiler that have been transformed into the .dex

format by the included "dx" tool. The Dalvik VM relies on the Linux kernel for underlying functionality

such as threading and low-level memory management. Unlike most virtual machines and true Jave VMs

which are stack machine, the Dalvik VM is a register-based architecture. Like the CISC vs. RISC debate, the

relative merits of stack machine vs. register-based approaches is a subject of continual argument.

Generally, stack-based machines must use instructions to load data on the stack and manipulate that data,

thus, require more instructions than register machines to implement the same high level code, but the

instructions in a register machine must encode the source and destination registers and, therefore, tend

to be larger. This difference is primarily of importance to VM interpreters for whom opcode dispatch

tends to be expensive and other factors are relevant for JIT compliation.

A tool called dx is used to convert Java .clasee files into the .dex format. Multiple classes are included in a

single .dex file. Duplicate strings and other constants used in multiple class files are included only once in

the .dex output to conserve space. Java bytecode is also converted into an alternate instruction set used

by the Dalvik VM. An uncompressed .dex file is typically a few percent smaller in size than a

compressed .jar (Java Archive) derived from the same .class files.

The Dalvik executables may be modified again when they get installed onto a mobile device. In order to

gain further optimization, byte order may be swapped in certain data, simple data structures and function

libraries may be linked inline, and empty class objects may be short-circuited, for example.

Being optimized for low memory requirements, Dalvik has some specific characteristics that differentiate

it from other standard VMs: The VM was slimmed down to use less space. Dalvik currently has no just-in-

time compiler, but Android 2.0 includes experimental source for one (disabled by default). The constant

pool has been modified to use only 32-bit indexes to simplify the interpreter. It uses its own bytecode, not

Java bytecode. Moreover, Dalvik has been designed so that a device can run multiple instances of the VM

efficiently.

For iPhone, Sun Microsystems plans to release a Java Virtual Machine (JVM) for iPhone OS, based on the

Java Platform, Micro Edition version of Java. This would enable Java applications to run on iPhone and

iPod Touch.

6 Conclusion

Table 1 compares features between iPhone 3.0 and Android.

Table 1 iPhone 3.0 vs. Android

MMS Support

Copy/Cut and Paste

Application Notification

Phone-wide Search

Email Search

Calendar Search

3G Tethering

Voice Over IP

File Sharing

Peer to Peer Bluetooth Connectivity

iPhone 3.0

Yes

Push Notifications

Yes

Android

Yes

Background Processes

Yes(Gmail search box)

Yes(3 -party app)

Yes

Compare with iPhone, Android provides developer more freedom. As Android is an open source,

developer can create and deploy anything on the device. Compare with iPhone OS, Android is more

widespread and applied in different model. Besides, Google provides many services like Google Search,

gTalk, Google Doc, Google Map and so on. Once integrate these services with Android, it can provide

customer more benefits.

iPhone OS, on the contrary, is designed exclusively for Apple’s products, like iPhone, iPod and iPad. This

helps to avoid reduce the functionality to suit the hardware needs for different devices. Also this focus

can help developers make more useful and powerful applications based on customers requirement.

Reference

Greg Kroah-Hartman. "Android and the Linux kernel

community" http://www.kroah.com/log/linux/android-kernel-problems.html.

"Linux developer explains Android kernel code removal". http://news.zdnet.com/2100-

9595_22-389733.html.

"What is Android". Android Developers. http://developer.android.com/guide/basics/what-is-

android.html.

Open Handset Alliance. "Industry Leaders Announce Open Platform for Mobile Devices".

http://www.openhandsetalliance.com/press_110507.html.

Bort, Dave. "Android is now available as open source". Android Open Source Project.

http://source.android.com/posts/opensource.

Honan, Matthew. "Apple unveils iPhone". Macworld.

http://www.macworld.com/article/54769/2007/01/iphone.html.

7. Android architecture. http://www.slideshare.net/deepakshare/android-arch-presentation

8. An overview of iPhone OS architecture.

http://thecoffeedesk.com/news/index.php/2009/05/17/iphone-architecture/

Fingerworks. http://www.fingerworks.com/

10. Into Mobile. http://www.intomobile.com/2009/06/18/iphone-3g-s-torn-apart-samsung-

s5pc100-arm-cortex-a8-600-mhz-inside-and-double-the-ram.html

Multiple APK Support in Android Market

2011-07-22T05:35:00.000-07:00

Posted by Dirk Dougherty on 21 July 2011 at 1:45 PM

[This post is by Eric Chu, Android Developer Ecosystem. —Dirk Dougherty]

At Google I/O we announced our plans to add several new capabilities to help developers manage their products more effectively in Android Market. We’re pleased to let you know that the latest of those, multiple APK support, is now available. Multiple APK support is a new publishing option in Android Market for those developers who want extra control over distribution.

Until now, each product listing on Android Market has included a single APK file, a universal payload that is deliverable to all eligible devices — across all platform versions, screen sizes, and chipsets. Broad distribution of a single APK works very well for almost all applications and has the advantage of simplified product maintenance.

With multiple APK support, you can now upload multiple versions of an APK for a single product listing, with each one addressing a different subset of your customers. These APKs are complete, independent APKs that share the same package name, but contain code and resources to target different Android platform versions, screen sizes, or GL texture-compression formats. When users download or purchase your app, Android Market chooses the right APK to deliver based on the characteristics of the device.

When you upload multiple APK files, Android Market handles them as part of a single product listing that aggregates the app details, ratings, and comments across the APKs. All users who browse your app’s details page see the same product with the same description, branding assets, screenshots, video, ratings, and comments. Android Market also aggregates the app’s download statistics, reviews, and billing data across all of the APKs.

Multiple APK support gives you a variety of ways to control app distribution. For example, you could use it to create separate APKs for phones and tablets under the same product listing. You could also use it to take advantage of new APIs or new hardware capabilities without impacting your existing customer base.

To support this new capability, we’ve updated the Developer Console to include controls for uploading and managing APKs in a product listing — we encourage you to take a look. If you’d like to learn more about how multiple APK support works, please read the developer documentation. As always, please feel free to give us feedback on the feature through the Market Help Center.

How can I setup a remote connection to MySQL?

2011-07-19T08:18:00.000-07:00

To remotely connect to your MySQL databases, you must have an I.P.-based account. Login to your control panel and click on the side menu "ValueApps" then the "Database" tab. If you have not installed MySQL, click on "MySQL Database" under Available ValueApps. If you have already installed MySQL, click on "MySQLs" under Installed ValueApps. Check the box "TCP/IP Connection". Now login to your account via SSH.
Use the MySQL monitor to grant privileges.
Start the MySQL monitor with this command:

mysql

or:

/usr/local/mysql/bin/mysql

Your shell prompt should now look like this:

mysql>

Run this command:

GRANT ALL PRIVILEGES ON *.* TO USERNAME@IP IDENTIFIED BY "PASSWORD";

USERNAME is the username that you would like to create.
IP is the public IP address of your remote connection. See examples
PASSWORD is the password you would like to use for this username. You now must flush MySQL's privileges. Run this command:

FLUSH PRIVILEGES;

Run this command to exit MySQL:

exit;

You can find your I.P. address by visiting these sites(opens a new window):
http://www.whatismyip.com
http://www.whatismyipaddress.net
http://www.showmyip.com
http://www.ipchicken.com

Connecting to remote MySQL database

2011-07-19T07:43:00.000-07:00

MySQL db can be connected from a remote location. Say at A mysql is running and from B I am trying to connect.
At A I have created a user for remote access like this .
Opened the dos prompt and gone to c:>cd mysql/bin
c:>mysql>cd bin
c:>mysql> mysql --user=root --password=mypassword
Here welcome message will appear. and then this line of SQL will grant previlage to remote user
grant select,insert,update, delete on db_name.* to user_name IDENTIFIED BY "user_password";
Here if the user has to be given remote access ( say from coumputer B ) then this should be
grant select,insert,update, delete on db_name.* to user_name@B IDENTIFIED BY "user_password";
This will allow remote access to user user_name from computer B. At computer B the server address can be the IP address of A and the user id and password will be same .

Setting up Stratos locally in your home computer is just a few steps away ..

2011-07-15T13:24:00.000-07:00

Now you can check out the trunk code of Carbon from the repository, build, and configure WSO2 Stratos in a few steps.

Check out https://svn.wso2.org/repos/wso2/trunk/carbon
mvn clean install from carbon directory

Set up the following in ~/.bashrc (change the values accordingly for the email addresses, carbon directory, the transport sender, and the other information given below.)

# Stratos setup constants
export stratos_local_ip="10.100.0.15"

export CARBON_DIR="/home/pradeeban/trunk/stratos/carbon"
export STRATOS_DIR=$CARBON_DIR/stratos_home
export STRATOS_VERSION=1.1.0-SNAPSHOT
export SSO_ENABLED=true
export CREATE_DB=true
export STRATOS_MAIL_TRANSPORT=' ********.***.***25 false false cloud-noreply@wso2.com '
export NOTIFICATION_EMAIL=pradeeban@wso2.com

If you are going to use the stratos binaries, you can use the downloaded packs, usually available from the builders online, as of the trunk or development branch version or from the wso2.org download area, for a released version.

Place the downloaded zips in to a location and also define that location in bashrc profile.
export PACKS_DIR="/home/pradeeban/Downloads"

Now you may run the set up script as above.

Running Stratos Set up script - carbon/build/stratos-setup.pl
./stratos-setup.pl

Add the following lines to your /etc/hosts file

127.0.0.1 cloud-test.wso2.com
127.0.0.1 identity.cloud-test.wso2.com
127.0.0.1 governance.cloud-test.wso2.com
127.0.0.1 appserver.cloud-test.wso2.com
127.0.0.1 bam.cloud-test.wso2.com
127.0.0.1 dss.cloud-test.wso2.com
127.0.0.1 bps.cloud-test.wso2.com
127.0.0.1 brs.cloud-test.wso2.com
127.0.0.1 cep.cloud-test.wso2.com
127.0.0.1 esb.cloud-test.wso2.com
127.0.0.1 gadget.cloud-test.wso2.com
127.0.0.1 mb.cloud-test.wso2.com
127.0.0.1 mashup.cloud-test.wso2.com

Start all the Stratos services
from $stratos_home
sh stratos.sh start all

Stop all the Stratos services
form $stratos_home
sh stratos.sh stop all

Also you can start and stop the services individually or as a chosen subset of all the available services.

Here by pointing the browser to cloud-test.wso2.com, you can access Stratos Manager. Pls note that in the configuration we have enabled SSO. You can also set up the Stratos services with SSO disabled instead, by setting export SSO_ENABLED=false,above in .bashrc profile.

Activity monitoring using WSO2 BAM Server

2011-07-15T13:22:00.001-07:00

In this scenario we will be monitoring requests and responses passed through a proxy service in WSO2 ESB. The proxy service is calling an in/out operation in an Axis2Service in WSO2 WSAS.

Lets make the setup.

A) Deploy the axis2 service in WSO2 App Server.

1. Download WSO2 App Server-3.2.1 distribution from here and extract it.

In this setup we are going to have 3 WSO2 servers running at the same time. Therefore, we need to change the http/https ports of each server to make the servers start in different ports. To do this go to the CARBON_HOME/repository/conf and update the http/https ports in mgt-transports.xml and axis2.xml files.

2. Start WSO2 App Server distribution by running the startup scripts in WSAS_HOME/bin/.
$ sh wso2server.sh in Ubuntu and
$ wso2server.bat in Windows.

3. Once the server is started, Sign-in to admin console and go to Services >Add >Axis2Service and upload this service.

Now we have WSO2 WSAS waiting with a service in it at http://192.168.1.4:9764/wsas/services/Axis2Service?wsdl. Let's setup WSO2 ESB.

B) Configure WSO2 ESB

1. Download a WSO2 ESB-3.0.1 distribution from here and extract it. Change its ports and start the server as instructed above.

2. Once the server is started, Sign-in to admin console and go to Manage > Service Bus > Source View. Paste the following configuration into the source view.

<proxy name="DemoProxy1" transports="https http" startOnLoad="true" trace="disable" statistics="enable">
        <target>
            <endpoint name="endpoint_act">
                <address uri="http://192.168.1.4:9764/wsas/services/Axis2Service/" statistics="enable"/>
            </endpoint>
            <inSequence statistics="enable">
                <log>
                    <property name="IN" value="*********IN****************"/>
                </log>
            </inSequence>
        </target>
        <publishWSDL uri="http://192.168.1.4:9764/wsas/services/Axis2Service?wsdl"/>
    </proxy>

NOTE: You may need to chnage the endpoint epr according to your network settings.

C) Add publisher jars to ESB.

We need to enable Activity Publishing in ESB. Since ESB doesn't have activity publishing feature in it by default, we need to add the relevant jars manually.
So download following org.wso2.carbon.bam.data.publisher.activity.mediation-3.0.1.jar & org.wso2.carbon.bam.data.publisher.activity.mediation.ui-3.0.1.jar and copy to ESB_HOME/repository/components/dropins/ folder. This will add 'Activity Publishing' menu to ESB admin console under Configure menu.

Also we need to update the org.wso2.carbon.bam.data.publisher.activity.mediation-3.0.1.jar in ESB_HOME/repository/components/plugins with this patched version.

Lastly we need to enable message tracing in ESB. Open ESB_HOME/repository/conf/carbon.xml and add this;

<MediationStat>
    <MessageTracing>enabled</MessageTracing>
</MediationStat>

In the next step access ESB UI and enable message tracing. Sign-in to ESB admin console, navigate to 'Activity Publishing. In the 'Activity Publisher Configuration' page enable message tracing, go to Activity Publishing and enable eventing.
Message Threshold will be set to 2 by default. This is the minimum number of messages you need to have in the que before being read by a subscriber.
Enable 'Message Dumping' and 'Message Lookup'. Xpath expression is the value from which your message will be filtered for the subscriber.

After configurations on ESB side is done, we need to configure WSO2 BAM to monitor messages from and to ESB.

D) Configure BAM

1. Download WSO2 BAM-1.2.0 distribution from here and extract it. Change its ports and start the server as instructed above.

NOTE: BAM is configured to use H2 database by default. If you want to connect to oracle, mySql or an MS SQL db you need to create the database by running a script and update driverClassName,url, username, password in datasources.properties file which resides in BAM_HOME/repository/conf. Details of configuring to other DBMSs are explained here.

2. Now start WSO2 BAM server and sign-in to the admin console.

3. Navigate to Configure > Monitored Servers > Add Servers.

4. Add the server information of your ESB server, which we are going to monitor. Since we are monitoring mediation, our data collection method should be 'eventing' and type of data thats traced will be 'message'. So the coonfiguration is:

Server URL : https://<server IP>:<server port>
Data Collection method : Eventing
Type of data : Messagega
User Name : user name for ESB
Password : Password for ESB

After this you will have an entry in the 'Monitored Servers' with the information you gave above.

E) Monitor the messages

1. Using a client send messages to the proxy service we created above. i am using following java client.

/*
*Copyright (c) 2005-2010, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
*
*WSO2 Inc. licenses this file to you 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 org.wso2.carbon.test;

import org.apache.axiom.om.OMAbstractFactory;
import org.apache.axiom.om.OMElement;
import org.apache.axiom.om.OMFactory;
import org.apache.axiom.om.OMNamespace;
import org.apache.axis2.AxisFault;
import org.apache.axis2.Constants;
import org.apache.axis2.addressing.EndpointReference;
import org.apache.axis2.client.Options;
import org.apache.axis2.client.ServiceClient;
import org.apache.axis2.transport.http.HTTPConstants;
import org.apache.commons.httpclient.HttpClient;
import org.apache.commons.httpclient.MultiThreadedHttpConnectionManager;

import javax.xml.namespace.QName;

public class EsbDemoProxy {

    private static EndpointReference targetEPR = new EndpointReference(
            "http://10.100.1.120:8280/bam/services/DemoProxy1");

    public static OMElement echoPayload(String x) {
        OMFactory fac = OMAbstractFactory.getOMFactory();
        OMNamespace omNs = fac.createOMNamespace("http://service.carbon.wso2.org", "example");
        OMElement method = fac.createOMElement("echoInt", omNs);
        OMElement value = fac.createOMElement("x", omNs);
        value.addChild(fac.createOMText(value, x));
        method.addChild(value);
        return method;
    }



    public static void main(String[] args) throws AxisFault {

        // creates a new connection manager and a http client object
        MultiThreadedHttpConnectionManager httpConnectionManager = new MultiThreadedHttpConnectionManager();
        HttpClient httpClient = new HttpClient(httpConnectionManager);
        for (int a = 0; a < 1; a++) {
            for (int i = 0; i < 1; i++) {
                ServiceClient sender = new ServiceClient();
                try {
                    OMElement payload1 = EsbDemoProxy.echoPayload("55");
                    Options options = new Options();
                    options.setTo(targetEPR);
                    options.setTransportInProtocol(Constants.TRANSPORT_HTTP);

                    OMFactory omFactory = OMAbstractFactory.getOMFactory();
                    OMElement omElement = omFactory.createOMElement(new QName("http://wso2.org/ns/2010/10/bam", "BAMEvent", "ns"), null);
                    omElement.addAttribute("activityID", "AAAAIsiasd-sdswodi-2329", null);

                    OMElement bampropertyElement = omFactory.createOMElement(new QName("http://wso2.org/ns/2010/10/bam", "Property", "ns"), null);
                    bampropertyElement.addAttribute("name", "ESB2_a", null);
                    bampropertyElement.addAttribute("value", "A", null);

                    omElement.addChild(bampropertyElement);
                    omElement.addChild(omElement);

                    sender.addHeader(omElement);

                    sender.setOptions(options);
                    OMElement result1 = sender.sendReceive(payload1);
                    String response1 = result1.getFirstElement().getText();
                    System.out.println(response1);

                } catch (Exception e) { // (XMLStreamException e) {
                    System.out.println(e.toString());
                }
                finally {
                    if (sender != null) {
                        try {
                            sender.cleanupTransport();
                        } catch (Exception e) {
                            e.printStackTrace();
                        }

                        try {
                            sender.cleanup();
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    }
                }

                httpConnectionManager.closeIdleConnections(0);
                httpConnectionManager.shutdown();
            }
        }
    }
}

2. After sending few messages you will be able to observe the messages from the BAM Admin Console > Main Dashboard > Actvity Tab

Configuring WSO2 BAM to connect to different Databases

2011-07-15T13:22:00.000-07:00

Connecting to mySql database.

1. You need to execute the mysql.sql in BAM_HOME/dbscripts folder.

- Navigate to where you have the above script.
- Login to MySQL as the root user.

mysql -u root -p

- give the password at the prompt

- Execute the mysql.sql script.

source mysql.sql

This will create the BAM database. To connect to the database you need to:

2. Copy the mysql driver to CARBON.
- Navigate to BAM_HOME/repository/components/lib and copy mysql-connector-java-5.1.7-bin.jar.

3. Update BAM_HOME/repository/conf/datasources.properties with your database information. A sample is done below.

synapse.datasources=bamMySQL
synapse.datasources.icFactory=com.sun.jndi.rmi.registry.RegistryContextFactory
synapse.datasources.providerPort=2199
synapse.datasources.bamh2.registry=JNDI
synapse.datasources.bamh2.type=BasicDataSource
synapse.datasources.bamh2.driverClassName=com.mysql.jdbc.Driver
synapse.datasources.bamh2.url=jdbc:mysql://localhost:3306/wso2bam_db
synapse.datasources.bamh2.username=wso2bam
synapse.datasources.bamh2.password=wso2bam‎
synapse.datasources.bamh2.dsName=bam_datasource
synapse.datasources.bamh2.maxActive=100
synapse.datasources.bamh2.maxIdle=20
synapse.datasources.bamh2.maxWait=10000

Connecting to Oracle database

1. You need to execute the oracle.sql in BAM_HOME/dbscripts folder.

- Login to SQLPlus as a sysdba and create the db user and grant required access.

$sqlplus sys as sysdba; 

SQL> startup
drop user wso2bam‎ cascade; 
Create user wso2bam‎ identified by wso2bam account unlock; 
grant connect to wso2bam; 
grant create session, dba to wso2bam;
commit;

Now login from the above created user and execute the oracle.sql script

sqlplus wso2bam/wso2bam@10.100.1.10/ORCL
SQL>>@/dbscripts/bam/bam_schema_oracle.sql;

This will create the BAM database. To connect to the database you need to:

2. Copy the mysql driver to CARBON.
- Navigate to BAM_HOME/repository/components/lib and copy ojdbc14.jar.

3. Update BAM_HOME/repository/conf/datasources.properties with your database information. A sample is done below.

synapse.datasources=bamOracle
synapse.datasources.icFactory=com.sun.jndi.rmi.registry.RegistryContextFactory
synapse.datasources.providerPort=2199
synapse.datasources.bamh2.registry=JNDI
synapse.datasources.bamh2.type=BasicDataSource
synapse.datasources.bamh2.driverClassName=oracle.jdbc.driver.OracleDriver
synapse.datasources.bamh2.url=jdbc:oracle:thin:@localhost:1521/wso2bam_db
synapse.datasources.bamh2.username=wso2bam
synapse.datasources.bamh2.password=wso2bam
synapse.datasources.bamh2.dsName=bam_datasource
synapse.datasources.bamh2.maxActive=100
synapse.datasources.bamh2.maxIdle=20
synapse.datasources.bamh2.maxWait=10000

Setting up WSO2 Stratos in personal machine

2011-07-15T13:21:00.000-07:00

Here are the steps to setup Stratos in your personal machine.

1. Checkout the stratos setting-up script from here.
https://svn.wso2.org/repos/wso2/trunk/carbon/build

2. Copy the wso2straos-manager-1.5.0, wso2stratos-is-1.5.0, wso2stratos-bam-1.5.0 distributions and the binary distributions of the services that you wish to include. i.e. wso2stratos-esb-1.5.0.
Lets mark this place where you copy these .zip files as PACKS_DIR.

3. Export following environment variables to your .bashrc

export PACKS_DIR="/home/yumani/Documents/packs/3.2.0"
export STRATOS_DIR="/home/yumani/Documents/Stratos/stratos320"
export STRATOS_VERSION=1.5.0
export SSO_ENABLED=true
export CREATE_DB=true

export STRATOS_MAIL_TRANSPORT='&lttransportsender class="org.apache.axis2.transport.mail.MailTransportSender" name="mailto"> &ltparameter name="mail.smtp.host"&gtcheetara.wso2.com</parameter>&ltparameter name="mail.smtp.port"&gt25</parameter> &ltparameter name="mail.smtp.starttls.enable"&gtfalse</parameter> &ltparameter name="mail.smtp.auth"&gtfalse</parameter>  &ltparameter name="mail.smtp.from"&gtcloud-noreply@wso2.com</parameter> </transportsender>'
export NOTIFICATION_EMAIL=xxxx@wso2.com

4. Run stratos-setup.pl. (NOTE: Before this you may need to install 'liblist-moreutils-perl' to execute the perl script)

5. Then update your /etc/hosts file with following;

127.0.0.1 cloud-test.wso2.com
127.0.0.1 identity.cloud-test.wso2.com
127.0.0.1 governance.cloud-test.wso2.com
127.0.0.1 appserver.cloud-test.wso2.com
127.0.0.1 bam.cloud-test.wso2.com
127.0.0.1 dss.cloud-test.wso2.com
127.0.0.1 bps.cloud-test.wso2.com
127.0.0.1 brs.cloud-test.wso2.com
127.0.0.1 cep.cloud-test.wso2.com
127.0.0.1 esb.cloud-test.wso2.com
127.0.0.1 gadget.cloud-test.wso2.com
127.0.0.1 mb.cloud-test.wso2.com
127.0.0.1 mashup.cloud-test.wso2.com

6. After this you can start the servers. You will find that the setting-up script has unzipped all the binary distributions (you copied to PACKS_DIR) into the STRATOS_DIR location which, you specified in .bachrc.

7. Go to above CARBON_HOME. You have two ways to start the cloud environment.
i. Running the stratos.sh in STRAROS_DIR. Using stratos.sh you can start all the services and the manager at once or a selected set of services and the manager.
i.e.

sh stratos.sh startall

sh stratos.sh wso2stratos-manager-1.5.0 wso2stratos-is-1.5.0 wso2stratos-bam-1.5.0

ii. Starting each service using its own startup scripts (CARBON_HOME/bin/wso2server.sh). This way you can first start the manager following wso2stratos-is and wsorstratos-bam. Then the other services as you wish.

That's all.. Now you can access wso2stratos-manager from browser and start using the cloud environment. URL for the stratos-manager can be gained from its startup logs which are printed on the back-end console.

Android: Too Many Pattern Attempts. Phone is locked.

2011-07-15T12:47:00.000-07:00

There you are, showing off your Android and that funky pattern lock feature. But you didn't think that some joker would try too many times and lock your phone for good. Not to bad, since you just need to wait 30 seconds to retry - or?

Not quite, if you do it too often, the phone will lock you out for good and you can only unlock by either wiping your phone or by logging into your Google account. The Google account feature sounds reasonable and easy --- but wait, your Wifi switch is not on (and you can only turn it on when unlocked).

Not all is lost, provided your phone is rooted and you have the Android toolkit installed (if "adb" means something to you, then read on):

Do the following:


> ./adb shell
# sqlite3 data/data/com.android.providers.settings/databases/settings.db
sqlite> update system set value=0 where name='lock_pattern_autolock';
sqlite> update system set value=0 where name='lockscreen.lockedoutpermanently';
sqlite> .exit
# exit

The above commands will connect to your settings-database and then disable the autolock as well as reset the permanent lock.

Useful Equinox OSGi commands

2011-07-15T12:37:00.000-07:00

Equinox is an implementation of the OSGi R4 core framework specification. This is the OSGi implementation which is used in WSO2 Carbon framework as well. Following commands are extremely useful in troubleshooting OSGi related issues.

ss (Ex: osgi> ss)
This command can be used to list all the existing bundles in the OSGi environment. Bundle ID, State and Bundle symbolic name of all the bundles are shown.

start <bundle-id> (Ex: osgi> start 16)
This command can be used to start a particular bundle. If it can’t be started, reasons are printed on the console.

stop <bundle-id> (Ex: osgi> stop 16)
This command can be used to stop a particular bundle. If it can’t be stopped, reasons are printed on the console.

b <bundle-id> (Ex: osgi> b 16)
This can be used to print all the meta data related to this bundle. That includes imported packages, exported packages, host bundle, required bundles etc.

diag <bundle-id> (Ex: osgi> diag 16)
This can be used to diagnose a particular bundle. It will show you the list of missing imported packages.

headers <bundle-id> (Ex: osgi> headers 16)
This can be used to list the headers for a particular bundle.

packages <package-name> (Ex: osgi> packages org.wso2.foo)
This can be used to list all the bundles which use the given package.

install file:<file-path> (Ex: osgi> install file:/home/temp/bundle1.jar)
This can be used to install a bundle into running OSGi environment. After installing, use ‘start’ command to activate the bundle.

uninstall <bundle-id> (Ex: osgi> uninstall 16)
This can be used to remove a bundle from the OSGi environment.

active (Ex: osgi> active)
This can be used to list all active bundles in the current instance.

refresh (Ex: osgi> refresh)
This can be used to refresh the system. All the package resolutions are refreshed when this is executed. Always refresh the system after uninstalling a bundle as a best practice.

Note : <bundle-symbolic-name> also can be used instead of <bundle-id> in above commands which uses <bundle-id> as a parameter.

OSGi with Eclipse Equinox - Tutorial

2011-07-15T12:36:00.000-07:00

Lars Vogel

Version 2.2

23.06.2011

Revision History
Revision 0.1	03.09.2007	Lars Vogel
Created
Revision 0.2 - 2.4	25.10.2008 - 23.06.2011	Lars Vogel
bugfixes and enhancements

OSGi with Eclipse Equinox

This tutorial gives an overview of OSGi. It explains the creation and consumption of OSGi services via ServiceTrackers and declarative services. Eclipse Equinox is used as an standalone OSGi server. For this tutorial Eclipse 3.7 (Indigo) is used.

Table of Contents

1. OSGi

1.1. Overview
1.2. Key features
1.3. Implementations
1.4. OSGi bundles
1.5. Bundle dependencies and public API
1.6. OSGi services
1.7. OSGi dependency management
1.8. Bundle Life cycle
1.9. OSGi MANIFEST.MF example

2. Installation

3. OSGI console

4. Your first OSGi bundle

4.1. Create
4.2. Coding
4.3. Run
4.4. Export your bundle

5. Running a standalone OSGI server

6. Define a Service and service consumption

6.1. Overview
6.2. How to build services
6.3. Define the service interface
6.4. Create service
6.5. Install service bundles
6.6. Use your service
6.7. Use your service with a service tracker
6.8. Problems with service tracker

7. Declarative Services

7.1. Overview
7.2. Define a declarative service
7.3. Review the result
7.4. Run declarative services

8. Using services via declarative services

9. Thank you

10. Questions and Discussion

11. Links and Literature

11.1. Source Code
11.2. OSGi Resources
11.3. vogella Resources

1. OSGi

1.1. Overview

OSGi is a specification of a service and module platform in Java at runtime. The core of the OSGi specification defines a component and service model. This component model allows to defines components and services and provides the means to activate, de-activate, update and de-install them dynamically.
The smallest unit of modularization in OSGi is a bundle. OSGi defines a registry which bundles can use to publish services or register to other services.

1.2. Key features

The key features of OSGi are:

Modularization
Runtime Dynamic
Service Orientation

In the authors personal opinion the strongest feature of OSGi is that you can define which package of your Java Projects should be visible to other Java projects. This way you can effectively control which Java classes in these projects can be used, e.g. define your API.

1.3. Implementations

OSGi has several implementations, for example Knopflerfish OSGi or Apache Felix. Eclipse Equinox is currently the reference implementation of the OSGi specification.
Eclipse Equinox is the runtime environment on which the Eclipse IDE and Eclipse RCP application are based. In Eclipse the smallest unit of modularization is a plugin . The terms plugin and bundle are (almost) interchangable. An Eclipse plugin is also an OSGi bundle and vice versa. Eclipse Equinox extends the concept of bundles with the concept of extension points .

1.4. OSGi bundles

The OSGi specification defines the OSGi bundle as the unit of modularization. A bundle is a cohesive, self-contained unit, which explicitly define its dependencies to other modules / services and explicitly defines its external API. OSGi bundles are .jar files with additional meta information. This meta information is stored in the folder "META-INF" in the file "MANIFEST.MF". MANIFEST.MF is part of a standard jar specification. Any non-OSGI runtime will ignore the OSGI metadata. Therefore OSGi bundles can be used without restriction in non-OSGi Java environments.
Each bundle has a symbolic name which is defined via the property "Bundle-SymbolicName" in the MANIFEST.MF. Convention is that this name starts with the reverse domain name of the author of the bundle, e.g. "de.vogella.myfirstbundle".
Each bundle has also a version number in the property "Bundle-Version". This version number and the symbolic name uniquely identify a bundle in OSGi. The OSGi runtime can load the same bundle with different version numbers.

1.5. Bundle dependencies and public API

Via MANIFEST.MF a bundle can define its dependency to other bundles and services. A bundle can define that it depends on a certain version (or a range) of another bundle, e.g. bundle A can define that it depends on bundle C in version 2.0, while bundle B defines that it depends on version 1.0 of bundle C.
If a class wants to use a class from another bundles this dependency must be defined in the MANIFEST.MF, otherwise you will receive a ClassNotFound Exception. This restriction is enforced via a specific OSGi classloader.
MANIFEST.MF also defines the Java classes which should be available to other bundles as public API. This definition is done based on the packages name. Classes which are not exported via the MANIFEST.MF are not visible to other bundles. This restriction is enforced in OSGi via a special Java class loader. Access to the restricted classes is not possible, also not via reflection.

1.6. OSGi services

A bundles can register and use services in OSGi. OSGi provides therefore a central registry for this purpose. A service is defined by a Java interface (POJI - plain old Java interface).
Access to the service registry is performed via the class BundleContext. OSGi injects the BundleContext into each bundle during the startup of the bundle. A bundle can also register itself to the BundleContext ServiceEvents which are for example triggered if a new service is installed or de-installed.

1.7. OSGi dependency management

OSGi is responsible for the dependency management between the bundles. These dependencies can be divided into:

Bundle (Package) Dependencies
Service Dependencies

OSGi reads the manifest.mf of a bundle during the installation of the plugin and ensures that all dependent bundles are also loaded if the bundle is activated. If the dependencies are not meet then the bundle is not loaded. Bundle / package dependencies are based on dependencies between standard Java objects and in case OSGi can not resolve all dependencies this results in a ClassNotFoundException.
As service in OSGi can be dynamically started and stopped, therefore the bundles must manage these dependencies themselves. The bundles can use the service listeners to get informed if a services is stared or stopped.

1.8. Bundle Life cycle

With the installation of a bundle in the OSGi runtime this bundle is persisted in a local bundle cache. The OSGi runtime is then trying to resolve all dependencies of the bundle. If all required dependencies are resolved the bundle is in the status "RESOLVED" otherwise it is in the status "INSTALLED". If several bundles exists which would satisfy the dependency then the bundle with the highest version is taking. If the version are the same then the bundle with the lowest ID is taken. If the bundle is started its status is "STARTING". Afterwards it is "ACTIVE".

1.9. OSGi MANIFEST.MF example

The following is an example of a MANIFEST.MF.

Manifest-Version: 1.0
Bundle-ManifestVersion: 2
Bundle-Name: Popup Plug-in
Bundle-SymbolicName: de.vogella.rcp.intro.commands.popup; singleton:=true
Bundle-Version: 1.0.0
Bundle-Activator: de.vogella.rcp.intro.commands.popup.Activator
Require-Bundle: org.eclipse.ui,
 org.eclipse.core.runtime
Bundle-ActivationPolicy: lazy
Bundle-RequiredExecutionEnvironment: JavaSE-1.6

Via the "Bundle-RequiredExecutionEnvironment" statement a bundle can specify which Java version is required to run the bundle. If this requirement is not fulfilled then the OSGi runtime does not load the bundle.

2. Installation

You need to have Java installed. I recommended to use Java 1.6.
Download Eclipse from the http://www.eclipse.org/ and unpack it to any directory. No installation procedure is required.

3. OSGI console

We will later use the OSGI console. This console is like a MS-DOS prompt. In this console you can type command to perform certain OSGI actions. For following is a reference of OSGi commands.
Use for example the command ss to get an overview of all bundles and their status.

Table 1. OSGi commands

Command	Desription
help	Lists the available commmands.
ss	Gives you an overview of the installed bundles and their status.
ss vogella	Gives you an overview of the bundles and their status if they have vogella within their name.
start id	Starts the bundle with id
stop id	Stops the bundle with id
install URL	Installs a bundles from an URL
uninstall id	Uninstalls the bundle with id
bundle "bundleid""	Show information about the bundle, including the registered and used services.
services filter	Show all available services and their consumer. Filter is an optional LDAP filter, e.g. to see all services use "services (objectclass=*ManagedService)".

Bundles can be identified via their id which is displayed by the command ss.
You can also access the OSGi console of your running Eclipse IDE . In the "Console" of your running Eclipse you find a menu entry with the tooltip "Open Console". If you select here "Host OSGi Console" you have access to your running OSGi instance. To see all available commands in the OSGi console type "help".

4. Your first OSGi bundle

The following will create a simple OSGi bundle and run it within Eclipse. At the end of this chapter you will also export your bundle to use it later in a standalone OSGi server.

4.1. Create

Create a new plugin project "de.vogella.osgi.firstbundle".

4.2. Coding

Create the following thread class.

package de.vogella.osgi.firstbundle.internal;

public class MyThread extends Thread {
 private volatile boolean active = true;

 public void run() {
  while (active) {
   System.out.println("Hello OSGI console");
   try {
    Thread.sleep(5000);
   } catch (Exception e) {
    System.out.println("Thread interrupted " + e.getMessage());
   }
  }
 }

 public void stopThread() {
  active = false;
 }
}

Change the class Activator.java to the following.

package de.vogella.osgi.firstbundle;

import org.osgi.framework.BundleActivator;
import org.osgi.framework.BundleContext;

import de.vogella.osgi.firstbundle.internal.MyThread;

public class Activator implements BundleActivator {
 private MyThread myThread;

 public void start(BundleContext context) throws Exception {
  System.out.println("Starting de.vogella.osgi.firstbundle");
  myThread = new MyThread();
  myThread.start();
 }

 
 public void stop(BundleContext context) throws Exception {
  System.out.println("Stopping de.vogella.osgi.firstbundle");
  myThread.stopThread();
  myThread.join();
 }

}

4.3. Run

Select your manifest.mf, right-click, select Run As-> Run Configuration. Create a OSGi Framework launch configuration. Deselect all bundles except your de.vogella.osgi.firstbundle. Press then "Add Required bundles".

Run this configuration. This should give you the following output. Every 5 second a new message should be written to the console.

4.4. Export your bundle

Export your bundle. This will allow you to install it into a OSGi runtime. Select your bundle and choose File -> Export -> Plug-in Development -> "Deployable plug-ins and fragment".

Unflag the option to export the source.

5. Running a standalone OSGI server

After running and creating bundles in Eclipse this chapter will show how to run Equinox as a OSGI standalone runtime. .
In your Eclipse installation directory identify the file org.eclipse.osgi*.jar. This file should be in the "plugin" folder. Copy this jar file to a new place, e.g. c:\temp\osgi-server. Rename the file to "org.eclipse.osgi.jar".
Start your OSGI server via the following command.

java -jar org.eclipse.osgi.jar -console

You can use "install URL" to install a bundle from a certain URL. For example to install your bundle from "c:\temp\bundles" use:

install file:c:\temp\bundles\plugins\de.vogella.osgi.firstbundle_1.0.0.jar

Tip

You properly need to correct the path and the bundle name on your system.

You can start then the bundle with start and the id.

Tip

You can remove all installed bundles with the -clean parameter.

6. Define a Service and service consumption

6.1. Overview

OSGi platform provides a flexible mechanism for provisioning functionality via services. In the following we will define and consume a service. Our service will return "famous quote".

6.2. How to build services

A service in OSGi is defined by a standard Java class or interface. It is common practice to define the service via a bundle which only contains the interface definition. This allows to change the implementation of the service via a different bundle.

6.3. Define the service interface

Create a plugin project "de.vogella.osgi.quote" and the package "de.vogella.osgi.quote". Do not use a template. You do not need an activator. Afterwards select the MANIFEST.MF and the "Runtime" tab. Add "de.vogella.osgi.quote" to the exported packages.

Create the following interface "IQuoteService".

package de.vogella.osgi.quote;

public interface IQuoteService {
 String getQuote();
}

6.4. Create service

We will now define a bundle which will provide the service.
Create a plugin project "de.vogella.osgi.quoteservice". Do not use a template.
Select the MANIFEST.MF and dependecy tab. Add "de.vogella.osgi.quote" to the required plugins.

Create the following class "QuoteService".

package de.vogella.osgi.quoteservice.internal;

import java.util.Random;

import de.vogella.osgi.quote.IQuoteService;

public class QuoteService implements IQuoteService {

 @Override
 public String getQuote() {
  Random random = new Random();
  // Create a number between 0 and 2
  int nextInt = random.nextInt(3);
  switch (nextInt) {
  case 0:
   return "Tell them I said something";
  case 1:
   return "I feel better already";
  default:
   return "Hubba Bubba, Baby!";
  }

 }
}

package de.vogella.osgi.quoteservice;

import java.util.Hashtable;

import org.osgi.framework.BundleActivator;
import org.osgi.framework.BundleContext;

import de.vogella.osgi.quote.IQuoteService;
import de.vogella.osgi.quoteservice.internal.QuoteService;

public class Activator implements BundleActivator {

 public void start(BundleContext context) throws Exception {
  IQuoteService service = new QuoteService();
  // Third parameter is a hashmap which allows to configure the service
  // Not required in this example
  context.registerService(IQuoteService.class.getName(), service,
    null);
  System.out.println("IQuoteService is registered");
 }

 public void stop(BundleContext context) throws Exception {
 }
}

6.5. Install service bundles

Export your bundles and install them on your server. Start the service bundle.

Tip

Nothing fancy happens, as we are not yet consuming our service.

6.6. Use your service

Create a new plugin "de.vogella.osgi.quoteconsumer". Add also a dependency to the package "de.vogella.osgi.quote".

Tip

Please note that we have added the dependency against the package NOT against the plugin. This way we later replace the service with a different implementation.

Lets register directly to the service and use it.

package de.vogella.osgi.quoteconsumer;

import org.osgi.framework.BundleActivator;
import org.osgi.framework.BundleContext;
import org.osgi.framework.ServiceReference;

import de.vogella.osgi.quote.IQuoteService;

public class Activator implements BundleActivator {

 private BundleContext context;
 private IQuoteService service;

 public void start(BundleContext context) throws Exception {
  this.context = context;
  // Register directly with the service
  ServiceReference reference = context
    .getServiceReference(IQuoteService.class.getName());
  service = (IQuoteService) context.getService(reference);
  System.out.println(service.getQuote());
 }

 public void stop(BundleContext context) throws Exception {
  System.out.println(service.getQuote());
 }

}

Export this bundle, install it and start and stop it. Everything work. But if you stop the service bundle then your receive an error.

The reason for this is that OSGi is a very dynamic environment and service may be registered and de-registered any time. The next chapter will use a service tracker to improve this.

6.7. Use your service with a service tracker

OSGi provides a service to track service events (new service / stop services / started service). For this the package "org.osgi.util.tracker" is used. This is part of the org.eclipse.osgi plugin.

To use this define the following class "MyQuoteServiceTrackerCustomizer"

package de.vogella.osgi.quoteconsumer;

import org.osgi.framework.BundleContext;
import org.osgi.framework.ServiceReference;
import org.osgi.util.tracker.ServiceTrackerCustomizer;

import de.vogella.osgi.quote.IQuoteService;

public class MyQuoteServiceTrackerCustomizer implements
  ServiceTrackerCustomizer {

 private final BundleContext context;

 public MyQuoteServiceTrackerCustomizer(BundleContext context) {
  this.context = context;
 }

 private MyThread thread;

 @Override
 public Object addingService(ServiceReference reference) {
  IQuoteService service = (IQuoteService) context.getService(reference);
  thread = new MyThread(service);
  thread.start();
  return service;
 }

 @Override
 public void modifiedService(ServiceReference reference, Object service) {
  // removedService(reference, service);
  // addingService(reference);
 }

 @Override
 public void removedService(ServiceReference reference, Object service) {
  context.ungetService(reference);
  System.out.println("How sad. Service for quote is gone");
  thread.stopThread();
 }

 public static class MyThread extends Thread {

  private volatile boolean active = true;
  private final IQuoteService service;

  public MyThread(IQuoteService service) {
   this.service = service;
  }

  public void run() {
   while (active) {
    System.out.println(service.getQuote());
    try {
     Thread.sleep(5000);
    } catch (Exception e) {
     System.out.println("Thread interrupted " + e.getMessage());
    }
   }
  }

  public void stopThread() {
   active = false;
  }
 }

}

You also need to register a service tracker in your activator of your serviceconsumer.

package de.vogella.osgi.quoteconsumer;

import org.osgi.framework.BundleActivator;
import org.osgi.framework.BundleContext;
import org.osgi.util.tracker.ServiceTracker;

import de.vogella.osgi.quote.IQuoteService;

public class Activator implements BundleActivator {

 private ServiceTracker serviceTracker;

 public void start(BundleContext context) throws Exception {
  System.out.println("Starting quoteconsumer bundles");
  // Register directly with the service
  MyQuoteServiceTrackerCustomizer customer = new MyQuoteServiceTrackerCustomizer(
    context);
  serviceTracker = new ServiceTracker(context, IQuoteService.class
    .getName(), customer);
  serviceTracker.open();
 }

 public void stop(BundleContext context) throws Exception {
  System.out.println("Stopping quoteconsumer bundles");
  serviceTracker.close();
 }

}

Export your bundle again. Start the OSGI console. Use the update command or the install command to get the new version of your bundle and start it. Once you start your service the tracker will be called and the consumer bundle will start writing messages to the console. Stop the service and verify that the consumer does not use the service anymore.

6.8. Problems with service tracker

The problem with service trackers it they still obey Java rules. In case your service consumer keeps a reference of the service, this service can not get removed via the OSGi framework. The other disadvantage is that the service tracker require a lot of boilerplate code. To solve these issues declarative services were developed.

7. Declarative Services

7.1. Overview

Declarative services (DS) allow to define and consume services via metadata (XML). Via DS you can define OSGi services without having any dependency to the OSGi platform, e.g. services can be defined as POJO's. This allows that these services can be tested independently of the OSGi runtime.
The "OSGi service component" is responsible for starting the service (service component). For the service consumer it is not visible if the service has been created via declarative service or via other means.
Service Components consists out of a XML description (Component Description) and an object (Component Instance). The component description contains all information about the service component, e.g. the class name of the component instance and the service interface.
A reference to the component description is maintained in the "MANIFEST.MF" file. This file is read by the OSGi runtime and if a component description is found the corresponding service is created. The component description in "MANIFEST.MF" looks for example like the following.

Service-Component: component.xml, OSGI-INF/component.xml

7.2. Define a declarative service

The following will define a DS service based on the quote example. It is therefore required that you have created the "de.vogella.osgi.quote" project which contains the interface definition.
Create a new plugin project "de.vogella.osgi.ds.quoteservice". Do not use a template, do not create an activator. Import package "de.vogella.osgi.quote" in MANIFST.MF on the tab "dependencies".
Create the Folder "OSGI-INF" in your project. Select the new folder, right-click on it and select New -> Other -> Plug-in Development -> Component Definition. The wizard will also add the "Service-Component" entry to "MANIFEST.MF".

This should open the service editor.

In component.xml switch to the service tab and press "Add" under "Provided Services" and select IQuoteService.

Create now the class "QuoteService" which implements the interface IQuoteService.

package de.vogella.osgi.ds.quoteservice;

import java.util.Random;

import de.vogella.osgi.quote.IQuoteService;

public class QuoteService implements IQuoteService {

 @Override
 public String getQuote() {
  Random random = new Random();
  // Create a number between 0 and 2
  int nextInt = random.nextInt(3);
  switch (nextInt) {
  case 0:
   return "Ds: Tell them I said something";
  case 1:
   return "Ds: I feel better already";
  default:
   return "Ds: Hubba Bubba, Baby!";
  }
 }

}

You have successfully defined a service via DS.

7.3. Review the result

Go back to component.xml and select the "Source". The declaration of the service looks like the following.

<?xml version="1.0" encoding="UTF-8"?>
<scr:component xmlns:scr="http://www.osgi.org/xmlns/scr/v1.1.0" name="de.vogella.osgi.ds.quoteservice">
   <implementation class="de.vogella.osgi.ds.quoteservice.QuoteService"/>
   <service>
      <provide interface="de.vogella.osgi.quote.IQuoteService"/>
   </service>
</scr:component>

This means that there is a component called "de.vogella.osgi.ds.quoteservice" which provides a service to the OSGI Service Registry under the interface "de.vogella.osgi.quote.IQuoteService", .and the component is implemented by the class "de.vogella.osgi.ds.quoteservice.QuoteService.
Check now the MANIFEST.MF. Here you find the entry: Service-Component: OSGI-INF/component.xml"

Manifest-Version: 1.0
Bundle-ManifestVersion: 2
Bundle-Name: Quoteservice
Bundle-SymbolicName: de.vogella.osgi.ds.quoteservice
Bundle-Version: 1.0.0.qualifier
Bundle-RequiredExecutionEnvironment: JavaSE-1.6
Import-Package: de.vogella.osgi.quote
Service-Component: OSGI-INF/component.xml

This defines that the plugin provides this services.

7.4. Run declarative services

Declaratives service require a few more bundles. In addition to "org.eclipse.osgi" you also require.

org.eclipse.equinox.util
org.eclipse.equinox.ds - Declarative service

Copy the "org.eclipse.equinox.ds*.jar", "org.eclipse.osgi.services.jar" and "org.eclipse.equinox.util*.jar" from your Eclipse/plugin installation directory into a folder, e.g. "C:\temp\bundles\plugins" and install the bundle into your OSGi runtime via.

install file:c:\temp\bundles\plugins\org.eclipse.equinox.ds.jar
install file:c:\temp\bundles\plugins\org.eclipse.equinox.util.jar
install file:c:\temp\bundles\plugins\org.eclipse.osgi.services.jar

Start the bundles manually so that declarative services are available.
Export your own bundle to "de.vogella.osgi.ds.quoteservice.jar". and install it via:

install file:c:\temp\bundles\plugins\de.vogella.osgi.ds.quoteservice.jar

To check if your service was registered use the command "services". This will list all installed and available services.
If you stop / uninstall the old service provider and start the new one your service should be picked up by the consumer.

8. Using services via declarative services

Of course you can also define the consumption of services via DS.
Create a new plugin "de.vogella.osgi.ds.quoteconsumer". Do not use a template, do not create an activator. Import the package "de.vogella.osgi.quote" in MANIFEST.MF on the tab "Dependencies".
Create the following class.

package de.vogella.osgi.ds.quoteconsumer;

import de.vogella.osgi.quote.IQuoteService;

public class QuoteConsumer {
 private IQuoteService service;

 public void quote() {
  System.out.println(service.getQuote());
 }
 
 // Method will be used by DS to set the quote service
 public synchronized void setQuote(IQuoteService service) {
  System.out.println("Service was set. Thank you DS!");
  this.service = service;
  // I know I should not use the service here but just for demonstration
  System.out.println(service.getQuote());
 }

 // Method will be used by DS to unset the quote service
 public synchronized void unsetQuote(IQuoteService service) {
  System.out.println("Service was unset. Why did you do this to me?");
  if (this.service == service) {
   this.service = null;
  }
 }
}

Tip

Note that this class has no dependency to OSGi.

Create the Folder "OSGI-INF" and create a new "Component Definition" in this folder.

This time we will use a service. Maintain the "Referenced Services".

Make the relationship to the bind / unbind method via by selecting your entry can pressing "Edit".

The result component.xml should look like:

<?xml version="1.0" encoding="UTF-8"?>
<scr:component xmlns:scr="http://www.osgi.org/xmlns/scr/v1.1.0" name="de.vogella.osgi.ds.quoteconsumer">
   <implementation class="de.vogella.osgi.ds.quoteconsumer.QuoteConsumer"/>
   <reference bind="setQuote" cardinality="1..1" interface="de.vogella.osgi.quote.IQuoteService" name="IQuoteService" policy="static" unbind="unsetQuote"/>
</scr:component>

The result MANIFEST.MF should look like:

Manifest-Version: 1.0
Bundle-ManifestVersion: 2
Bundle-Name: Quoteconsumer
Bundle-SymbolicName: de.vogella.osgi.ds.quoteconsumer
Bundle-Version: 1.0.4
Bundle-RequiredExecutionEnvironment: JavaSE-1.6
Import-Package: de.vogella.osgi.quote
Service-Component: OSGI-INF/component.xml

Export your plugin and install it via: install file:c:\temp\bundles\plugins \de.vogella.osgi.ds.quoteconsumer.jar
"If you start the bundle now with "start id_of_your_bundle" you should get the feedback that the service was set and one quote should be returned

9. Thank you

Please help me to support this article:

10. Questions and Discussion

Before posting questions, please see the vogella FAQ . If you have questions or find an error in this article please use the www.vogella.de Google Group . I have created a short list how to create good questions which might also help you.

11. Links and Literature

11.1. Source Code

Source Code of Examples

11.2. OSGi Resources

http://www.osgi.org OSGi Homepage
http://www.eclipse.org/equinox Equinox Homepage
http://www.eclipse.org/equinox/documents/quickstart.php Equinox Quickstart guide
http://www.ibm.com/developerworks/opensource/library/os-osgiblueprint/ OSGi Blueprint services

11.3. vogella Resources

Eclipse RCP Training Join my Eclipse RCP Training to become an RCP Expert in 5 days (Training in German)
Android Tutorial Introduction to Android Programming
GWT Tutorial Program in Java and compile to JavaScript and HTML
Eclipse RCP Tutorial Create native applications in Java
JUnit Tutorial Test your application
Git Tutorial Put everything you have under distributed version control system

OSGi Console Commands

2011-07-15T12:33:00.000-07:00

Command	Description
bundle-level	Gets or sets the start level of a given bundle
headers	Displays OSGi headers
install	Installs bundles
list	Lists the bundles
ls	Lists services
refresh	Refreshes the bundle
resolve	Resolves the bundle
restart	Restarts the bundle
shutdown	Shuts down OSGi
start	Starts the bundle
start-level	Gets or sets the start level
stop	Stops the bundle
uninstall	Uninstalls the bundle
update	Updates the bundle

Lock the Android phone with a password Sample

2011-07-12T06:41:00.000-07:00

/*
 * Copyright (C) 2010 The Android Open Source Project
 *
 * 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.example.android.apis.app;
import com.example.android.apis.R;
import android.app.Activity;
import android.app.ActivityManager;
import android.app.AlertDialog;
import android.app.admin.DeviceAdminReceiver;
import android.app.admin.DevicePolicyManager;
import android.content.ComponentName;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.SharedPreferences;
import android.os.Bundle;
import android.text.Editable;
import android.text.TextWatcher;
import android.util.Log;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.AdapterView;
import android.widget.AdapterView.OnItemSelectedListener;
import android.widget.ArrayAdapter;
import android.widget.Button;
import android.widget.EditText;
import android.widget.Spinner;
import android.widget.TextView;
import android.widget.Toast;
import java.text.DateFormat;
import java.util.Date;
/**
 * Example of a do-nothing admin class.  When enabled, it lets you control
 * some of its policy and reports when there is interesting activity.
 */
public class DeviceAdminSample extends DeviceAdminReceiver {

    private static final String TAG = "DeviceAdminSample";
    private static final long MS_PER_DAY = 86400 * 1000;
    private static final long MS_PER_HOUR = 3600 * 1000;
    private static final long MS_PER_MINUTE = 60 * 1000;

    static SharedPreferences getSamplePreferences(Context context) {
        return context.getSharedPreferences(DeviceAdminReceiver.class.getName(), 0);
    }

    static String PREF_PASSWORD_QUALITY = "password_quality";
    static String PREF_PASSWORD_LENGTH = "password_length";
    static String PREF_PASSWORD_MINIMUM_LETTERS = "password_minimum_letters";
    static String PREF_PASSWORD_MINIMUM_UPPERCASE = "password_minimum_uppercase";
    static String PREF_PASSWORD_MINIMUM_LOWERCASE = "password_minimum_lowercase";
    static String PREF_PASSWORD_MINIMUM_NUMERIC = "password_minimum_numeric";
    static String PREF_PASSWORD_MINIMUM_SYMBOLS = "password_minimum_symbols";
    static String PREF_PASSWORD_MINIMUM_NONLETTER = "password_minimum_nonletter";
    static String PREF_PASSWORD_HISTORY_LENGTH = "password_history_length";
    static String PREF_PASSWORD_EXPIRATION_TIMEOUT = "password_expiration_timeout";
    static String PREF_MAX_FAILED_PW = "max_failed_pw";

    void showToast(Context context, CharSequence msg) {
        Toast.makeText(context, "Sample Device Admin: " + msg, Toast.LENGTH_SHORT).show();
    }

    @Override
    public void onEnabled(Context context, Intent intent) {
        showToast(context, "enabled");
    }

    @Override
    public CharSequence onDisableRequested(Context context, Intent intent) {
        return "This is an optional message to warn the user about disabling.";
    }

    @Override
    public void onDisabled(Context context, Intent intent) {
        showToast(context, "disabled");
    }

    @Override
    public void onPasswordChanged(Context context, Intent intent) {
        showToast(context, "pw changed");
    }

    @Override
    public void onPasswordFailed(Context context, Intent intent) {
        showToast(context, "pw failed");
    }

    @Override
    public void onPasswordSucceeded(Context context, Intent intent) {
        showToast(context, "pw succeeded");
    }

    static String countdownString(long time) {
        long days = time / MS_PER_DAY;
        long hours = (time / MS_PER_HOUR) % 24;
        long minutes = (time / MS_PER_MINUTE) % 60;
        return days + "d" + hours + "h" + minutes + "m";
    }

    @Override
    public void onPasswordExpiring(Context context, Intent intent) {
        DevicePolicyManager dpm = (DevicePolicyManager) context.getSystemService(
                Context.DEVICE_POLICY_SERVICE);
        long expr = dpm.getPasswordExpiration(new ComponentName(context, DeviceAdminSample.class));
        long delta = expr - System.currentTimeMillis();
        boolean expired = delta < 0L;
        String msg = expired ? "Password expired " : "Password will expire "
                + countdownString(Math.abs(delta))
                + (expired ? " ago" : " from now");
        showToast(context, msg);
        Log.v(TAG, msg);
    }

    /**
     * <p>UI control for the sample device admin.  This provides an interface
     * to enable, disable, and perform other operations with it to see
     * their effect.</p>
     *
     * <p>Note that this is implemented as an inner class only keep the sample
     * all together; typically this code would appear in some separate class.
     */
    public static class Controller extends Activity {

        static final int REQUEST_CODE_ENABLE_ADMIN = 1;
        static final int REQUEST_CODE_START_ENCRYPTION = 2;

        private static final long MS_PER_MINUTE = 60*1000;

        DevicePolicyManager mDPM;
        ActivityManager mAM;
        ComponentName mDeviceAdminSample;

        Button mEnableButton;
        Button mDisableButton;

        // Password quality spinner choices
        // This list must match the list found in samples/ApiDemos/res/values/arrays.xml
        final static int mPasswordQualityValues[] = new int[] {
            DevicePolicyManager.PASSWORD_QUALITY_UNSPECIFIED,
            DevicePolicyManager.PASSWORD_QUALITY_SOMETHING,
            DevicePolicyManager.PASSWORD_QUALITY_NUMERIC,
            DevicePolicyManager.PASSWORD_QUALITY_ALPHABETIC,
            DevicePolicyManager.PASSWORD_QUALITY_ALPHANUMERIC,
            DevicePolicyManager.PASSWORD_QUALITY_COMPLEX
        };

        Spinner mPasswordQuality;
        EditText mPasswordLength;
        EditText mPasswordMinimumLetters;
        EditText mPasswordMinimumUppercase;
        EditText mPasswordMinimumLowercase;
        EditText mPasswordMinimumNumeric;
        EditText mPasswordMinimumSymbols;
        EditText mPasswordMinimumNonLetter;
        EditText mPasswordHistoryLength;
        Button mSetPasswordButton;

        EditText mPassword;
        Button mResetPasswordButton;

        EditText mMaxFailedPw;

        Button mForceLockButton;
        Button mWipeDataButton;
        Button mWipeAllDataButton;

        private Button mTimeoutButton;

        private EditText mTimeout;

        private EditText mPasswordExpirationTimeout;
        private Button mPasswordExpirationButton;
        private TextView mPasswordExpirationStatus;
        private Button mPasswordExpirationStatusButton;

        private Button mEnableEncryptionButton;
        private Button mDisableEncryptionButton;
        private Button mActivateEncryptionButton;
        private Button mEncryptionStatusButton;
        private TextView mEncryptionStatus;

        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);

            mDPM = (DevicePolicyManager)getSystemService(Context.DEVICE_POLICY_SERVICE);
            mAM = (ActivityManager)getSystemService(Context.ACTIVITY_SERVICE);
            mDeviceAdminSample = new ComponentName(Controller.this, DeviceAdminSample.class);

            setContentView(R.layout.device_admin_sample);

            // Watch for button clicks.
            mEnableButton = (Button)findViewById(R.id.enable);
            mEnableButton.setOnClickListener(mEnableListener);
            mDisableButton = (Button)findViewById(R.id.disable);
            mDisableButton.setOnClickListener(mDisableListener);

            mPasswordQuality = (Spinner)findViewById(R.id.password_quality);
            ArrayAdapter<CharSequence> adapter = ArrayAdapter.createFromResource(
                    this, R.array.password_qualities, android.R.layout.simple_spinner_item);
            adapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
            mPasswordQuality.setAdapter(adapter);
            mPasswordQuality.setOnItemSelectedListener(
                    new OnItemSelectedListener() {
                        public void onItemSelected(
                                AdapterView<?> parent, View view, int position, long id) {
                            setPasswordQuality(mPasswordQualityValues[position]);
                        }

                        public void onNothingSelected(AdapterView<?> parent) {
                            setPasswordQuality(DevicePolicyManager.PASSWORD_QUALITY_UNSPECIFIED);
                        }
                    });
            mPasswordLength = (EditText)findViewById(R.id.password_length);
            mPasswordLength.addTextChangedListener(new TextWatcher() {
                public void afterTextChanged(Editable s) {
                }
                public void beforeTextChanged(CharSequence s, int start, int count, int after) {
                }
                public void onTextChanged(CharSequence s, int start, int before, int count) {
                    try {
                        setPasswordLength(Integer.parseInt(s.toString()));
                    } catch (NumberFormatException e) {
                    }
                }
            });
            mPasswordMinimumLetters = (EditText)findViewById(R.id.password_minimum_letters);
            mPasswordMinimumLetters.addTextChangedListener(new TextWatcher() {
                public void afterTextChanged(Editable s) {
                }
                public void beforeTextChanged(CharSequence s, int start, int count, int after) {
                }
                public void onTextChanged(CharSequence s, int start, int before, int count) {
                    try {
                        setPasswordMinimumLetters(Integer.parseInt(s.toString()));
                    } catch (NumberFormatException e) {
                    }
                }
            });
            mPasswordMinimumUppercase = (EditText)findViewById(R.id.password_minimum_uppercase);
            mPasswordMinimumUppercase.addTextChangedListener(new TextWatcher() {
                public void afterTextChanged(Editable s) {
                }
                public void beforeTextChanged(CharSequence s, int start, int count, int after) {
                }
                public void onTextChanged(CharSequence s, int start, int before, int count) {
                    try {
                        setPasswordMinimumUppercase(Integer.parseInt(s.toString()));
                    } catch (NumberFormatException e) {
                    }
                }
            });
            mPasswordMinimumLowercase = (EditText)findViewById(R.id.password_minimum_lowercase);
            mPasswordMinimumLowercase.addTextChangedListener(new TextWatcher() {
                public void afterTextChanged(Editable s) {
                }
                public void beforeTextChanged(CharSequence s, int start, int count, int after) {
                }
                public void onTextChanged(CharSequence s, int start, int before, int count) {
                    try {
                        setPasswordMinimumLowercase(Integer.parseInt(s.toString()));
                    } catch (NumberFormatException e) {
                    }
                }
            });
            mPasswordMinimumNumeric = (EditText)findViewById(R.id.password_minimum_numeric);
            mPasswordMinimumNumeric.addTextChangedListener(new TextWatcher() {
                public void afterTextChanged(Editable s) {
                }
                public void beforeTextChanged(CharSequence s, int start, int count, int after) {
                }
                public void onTextChanged(CharSequence s, int start, int before, int count) {
                    try {
                        setPasswordMinimumNumeric(Integer.parseInt(s.toString()));
                    } catch (NumberFormatException e) {
                    }
                }
            });
            mPasswordMinimumSymbols = (EditText)findViewById(R.id.password_minimum_symbols);
            mPasswordMinimumSymbols.addTextChangedListener(new TextWatcher() {
                public void afterTextChanged(Editable s) {
                }
                public void beforeTextChanged(CharSequence s, int start, int count, int after) {
                }
                public void onTextChanged(CharSequence s, int start, int before, int count) {
                    try {
                        setPasswordMinimumSymbols(Integer.parseInt(s.toString()));
                    } catch (NumberFormatException e) {
                    }
                }
            });
            mPasswordMinimumNonLetter = (EditText)findViewById(R.id.password_minimum_nonletter);
            mPasswordMinimumNonLetter.addTextChangedListener(new TextWatcher() {
                public void afterTextChanged(Editable s) {
                }
                public void beforeTextChanged(CharSequence s, int start, int count, int after) {
                }
                public void onTextChanged(CharSequence s, int start, int before, int count) {
                    try {
                        setPasswordMinimumNonLetter(Integer.parseInt(s.toString()));
                    } catch (NumberFormatException e) {
                    }
                }
            });
            mPasswordHistoryLength = (EditText)findViewById(R.id.password_history_length);
            mPasswordHistoryLength.addTextChangedListener(new TextWatcher() {
                public void afterTextChanged(Editable s) {
                }
                public void beforeTextChanged(CharSequence s, int start, int count, int after) {
                }
                public void onTextChanged(CharSequence s, int start, int before, int count) {
                    try {
                        setPasswordHistoryLength(Integer.parseInt(s.toString()));
                    } catch (NumberFormatException e) {
                    }
                }
            });

            mPasswordExpirationTimeout = (EditText)findViewById(R.id.password_expiration);
            mPasswordExpirationButton = (Button) findViewById(R.id.update_expiration_button);
            mPasswordExpirationButton.setOnClickListener(new OnClickListener() {
                public void onClick(View v) {
                    try {
                        setPasswordExpiration(
                                Long.parseLong(mPasswordExpirationTimeout.getText().toString()));
                    } catch (NumberFormatException nfe) {
                    }
                    updatePasswordExpirationStatus();
                }
            });

            mPasswordExpirationStatus = (TextView) findViewById(R.id.password_expiration_status);
            mPasswordExpirationStatusButton =
                    (Button) findViewById(R.id.update_expiration_status_button);
            mPasswordExpirationStatusButton.setOnClickListener(new OnClickListener() {
                public void onClick(View v) {
                    updatePasswordExpirationStatus();
                }
            });

            mSetPasswordButton = (Button)findViewById(R.id.set_password);
            mSetPasswordButton.setOnClickListener(mSetPasswordListener);

            mPassword = (EditText)findViewById(R.id.password);
            mResetPasswordButton = (Button)findViewById(R.id.reset_password);
            mResetPasswordButton.setOnClickListener(mResetPasswordListener);

            mMaxFailedPw = (EditText)findViewById(R.id.max_failed_pw);
            mMaxFailedPw.addTextChangedListener(new TextWatcher() {
                public void afterTextChanged(Editable s) {
                }
                public void beforeTextChanged(CharSequence s, int start, int count, int after) {
                }
                public void onTextChanged(CharSequence s, int start, int before, int count) {
                    try {
                        int maxFailCount = Integer.parseInt(s.toString());
                        if (maxFailCount > 0) {
                            Toast.makeText(Controller.this, "WARNING: Phone will wipe after " +
                                    s + " incorrect passwords", Toast.LENGTH_SHORT).show();
                        }
                        setMaxFailedPw(maxFailCount);
                    } catch (NumberFormatException e) {
                    }
                }
            });

            mForceLockButton = (Button)findViewById(R.id.force_lock);
            mForceLockButton.setOnClickListener(mForceLockListener);
            mWipeDataButton = (Button)findViewById(R.id.wipe_data);
            mWipeDataButton.setOnClickListener(mWipeDataListener);
            mWipeAllDataButton = (Button)findViewById(R.id.wipe_all_data);
            mWipeAllDataButton.setOnClickListener(mWipeDataListener);

            mTimeout = (EditText) findViewById(R.id.timeout);
            mTimeoutButton = (Button) findViewById(R.id.set_timeout);
            mTimeoutButton.setOnClickListener(mSetTimeoutListener);

            mEnableEncryptionButton = (Button) findViewById(R.id.encryption_enable_button);
            mEnableEncryptionButton.setOnClickListener(mEncryptionButtonListener);
            mDisableEncryptionButton = (Button) findViewById(R.id.encryption_disable_button);
            mDisableEncryptionButton.setOnClickListener(mEncryptionButtonListener);
            mActivateEncryptionButton = (Button) findViewById(R.id.encryption_activate_button);
            mActivateEncryptionButton.setOnClickListener(mEncryptionButtonListener);
            mEncryptionStatusButton = (Button) findViewById(R.id.encryption_update_status_button);
            mEncryptionStatusButton.setOnClickListener(mEncryptionButtonListener);
            mEncryptionStatus = (TextView) findViewById(R.id.encryption_status);
        }

        void updateButtonStates() {
            boolean active = mDPM.isAdminActive(mDeviceAdminSample);
            if (active) {
                mEnableButton.setEnabled(false);
                mDisableButton.setEnabled(true);
                mPasswordQuality.setEnabled(true);
                mPasswordLength.setEnabled(true);
                mPasswordMinimumLetters.setEnabled(true);
                mPasswordMinimumUppercase.setEnabled(true);
                mPasswordMinimumLowercase.setEnabled(true);
                mPasswordMinimumSymbols.setEnabled(true);
                mPasswordMinimumNumeric.setEnabled(true);
                mPasswordMinimumNonLetter.setEnabled(true);
                mPasswordHistoryLength.setEnabled(true);
                mSetPasswordButton.setEnabled(true);
                mPassword.setEnabled(true);
                mResetPasswordButton.setEnabled(true);
                mForceLockButton.setEnabled(true);
                mWipeDataButton.setEnabled(true);
                mWipeAllDataButton.setEnabled(true);
                mEnableEncryptionButton.setEnabled(true);
                mDisableEncryptionButton.setEnabled(true);
                mActivateEncryptionButton.setEnabled(true);
                mEncryptionStatusButton.setEnabled(true);
            } else {
                mEnableButton.setEnabled(true);
                mDisableButton.setEnabled(false);
                mPasswordQuality.setEnabled(false);
                mPasswordLength.setEnabled(false);
                mPasswordMinimumLetters.setEnabled(false);
                mPasswordMinimumUppercase.setEnabled(false);
                mPasswordMinimumLowercase.setEnabled(false);
                mPasswordMinimumSymbols.setEnabled(false);
                mPasswordMinimumNumeric.setEnabled(false);
                mPasswordMinimumNonLetter.setEnabled(false);
                mPasswordHistoryLength.setEnabled(false);
                mSetPasswordButton.setEnabled(false);
                mPassword.setEnabled(false);
                mResetPasswordButton.setEnabled(false);
                mForceLockButton.setEnabled(false);
                mWipeDataButton.setEnabled(false);
                mWipeAllDataButton.setEnabled(false);
                mEnableEncryptionButton.setEnabled(false);
                mDisableEncryptionButton.setEnabled(false);
                mActivateEncryptionButton.setEnabled(false);
                mEncryptionStatusButton.setEnabled(false);
            }
        }

        void updateControls() {
            SharedPreferences prefs = getSamplePreferences(this);
            final int pwQuality = prefs.getInt(PREF_PASSWORD_QUALITY,
                    DevicePolicyManager.PASSWORD_QUALITY_UNSPECIFIED);
            final int pwLength = prefs.getInt(PREF_PASSWORD_LENGTH, 0);
            final int pwMinLetters = prefs.getInt(PREF_PASSWORD_MINIMUM_LETTERS, 0);
            final int pwMinUppercase = prefs.getInt(PREF_PASSWORD_MINIMUM_UPPERCASE, 0);
            final int pwMinLowercase = prefs.getInt(PREF_PASSWORD_MINIMUM_LOWERCASE, 0);
            final int pwMinNumeric = prefs.getInt(PREF_PASSWORD_MINIMUM_NUMERIC, 0);
            final int pwMinSymbols = prefs.getInt(PREF_PASSWORD_MINIMUM_SYMBOLS, 0);
            final int pwMinNonLetter = prefs.getInt(PREF_PASSWORD_MINIMUM_NONLETTER, 0);
            final int pwHistoryLength = prefs.getInt(PREF_PASSWORD_HISTORY_LENGTH, 0);
            final long pwExpirationTimeout = prefs.getLong(PREF_PASSWORD_EXPIRATION_TIMEOUT, 0L);
            final int maxFailedPw = prefs.getInt(PREF_MAX_FAILED_PW, 0);

            for (int i=0; i<mPasswordQualityValues.length; i++) {
                if (mPasswordQualityValues[i] == pwQuality) {
                    mPasswordQuality.setSelection(i);
                }
            }
            mPasswordLength.setText(Integer.toString(pwLength));
            mPasswordMinimumLetters.setText(Integer.toString(pwMinLetters));
            mPasswordMinimumUppercase.setText(Integer.toString(pwMinUppercase));
            mPasswordMinimumLowercase.setText(Integer.toString(pwMinLowercase));
            mPasswordMinimumSymbols.setText(Integer.toString(pwMinSymbols));
            mPasswordMinimumNumeric.setText(Integer.toString(pwMinNumeric));
            mPasswordMinimumNonLetter.setText(Integer.toString(pwMinNonLetter));
            mPasswordHistoryLength.setText(Integer.toString(pwHistoryLength));
            mPasswordExpirationTimeout.setText(Long.toString(pwExpirationTimeout/MS_PER_MINUTE));
            mMaxFailedPw.setText(Integer.toString(maxFailedPw));
        }

        void updatePasswordExpirationStatus() {
            boolean active = mDPM.isAdminActive(mDeviceAdminSample);
            String statusText;
            if (active) {
                long now = System.currentTimeMillis();
                // We'll query the DevicePolicyManager twice - first for the expiration values
                // set by the sample app, and later, for the system values (which may be different
                // if there is another administrator active.)
                long expirationDate = mDPM.getPasswordExpiration(mDeviceAdminSample);
                long mSecUntilExpiration = expirationDate - now;
                if (mSecUntilExpiration >= 0) {
                    statusText = "Expiration in " + countdownString(mSecUntilExpiration);
                } else {
                    statusText = "Expired " + countdownString(-mSecUntilExpiration) + " ago";
                }

                // expirationTimeout is the cycle time between required password refresh
                long expirationTimeout = mDPM.getPasswordExpirationTimeout(mDeviceAdminSample);
                statusText += " / timeout period " + countdownString(expirationTimeout);

                // Now report the aggregate (global) expiration time
                statusText += " / Aggregate ";
                expirationDate = mDPM.getPasswordExpiration(null);
                mSecUntilExpiration = expirationDate - now;
                if (mSecUntilExpiration >= 0) {
                    statusText += "expiration in " + countdownString(mSecUntilExpiration);
                } else {
                    statusText += "expired " + countdownString(-mSecUntilExpiration) + " ago";
                }
            } else {
                statusText = "<inactive>";
            }
            mPasswordExpirationStatus.setText(statusText);
        }

        void updatePolicies() {
            SharedPreferences prefs = getSamplePreferences(this);
            final int pwQuality = prefs.getInt(PREF_PASSWORD_QUALITY,
                    DevicePolicyManager.PASSWORD_QUALITY_UNSPECIFIED);
            final int pwLength = prefs.getInt(PREF_PASSWORD_LENGTH, 0);
            final int pwMinLetters = prefs.getInt(PREF_PASSWORD_MINIMUM_LETTERS, 0);
            final int pwMinUppercase = prefs.getInt(PREF_PASSWORD_MINIMUM_UPPERCASE, 0);
            final int pwMinLowercase = prefs.getInt(PREF_PASSWORD_MINIMUM_LOWERCASE, 0);
            final int pwMinNumeric = prefs.getInt(PREF_PASSWORD_MINIMUM_NUMERIC, 0);
            final int pwMinSymbols = prefs.getInt(PREF_PASSWORD_MINIMUM_SYMBOLS, 0);
            final int pwMinNonLetter = prefs.getInt(PREF_PASSWORD_MINIMUM_NONLETTER, 0);
            final int pwHistoryLength = prefs.getInt(PREF_PASSWORD_HISTORY_LENGTH, 0);
            final long pwExpiration = prefs.getLong(PREF_PASSWORD_EXPIRATION_TIMEOUT, 0L);
            final int maxFailedPw = prefs.getInt(PREF_MAX_FAILED_PW, 0);

            boolean active = mDPM.isAdminActive(mDeviceAdminSample);
            if (active) {
                mDPM.setPasswordQuality(mDeviceAdminSample, pwQuality);
                mDPM.setPasswordMinimumLength(mDeviceAdminSample, pwLength);
                mDPM.setPasswordMinimumLetters(mDeviceAdminSample, pwMinLetters);
                mDPM.setPasswordMinimumUpperCase(mDeviceAdminSample, pwMinUppercase);
                mDPM.setPasswordMinimumLowerCase(mDeviceAdminSample, pwMinLowercase);
                mDPM.setPasswordMinimumNumeric(mDeviceAdminSample, pwMinNumeric);
                mDPM.setPasswordMinimumSymbols(mDeviceAdminSample, pwMinSymbols);
                mDPM.setPasswordMinimumNonLetter(mDeviceAdminSample, pwMinNonLetter);
                mDPM.setPasswordHistoryLength(mDeviceAdminSample, pwHistoryLength);
                mDPM.setMaximumFailedPasswordsForWipe(mDeviceAdminSample, maxFailedPw);
                mDPM.setPasswordExpirationTimeout(mDeviceAdminSample, pwExpiration);
            }
        }

        void setPasswordQuality(int quality) {
            SharedPreferences prefs = getSamplePreferences(this);
            prefs.edit().putInt(PREF_PASSWORD_QUALITY, quality).commit();
            updatePolicies();
        }

        void setPasswordLength(int length) {
            SharedPreferences prefs = getSamplePreferences(this);
            prefs.edit().putInt(PREF_PASSWORD_LENGTH, length).commit();
            updatePolicies();
        }

        void setPasswordMinimumLetters(int length) {
            SharedPreferences prefs = getSamplePreferences(this);
            prefs.edit().putInt(PREF_PASSWORD_MINIMUM_LETTERS, length).commit();
            updatePolicies();
        }

        void setPasswordMinimumUppercase(int length) {
            SharedPreferences prefs = getSamplePreferences(this);
            prefs.edit().putInt(PREF_PASSWORD_MINIMUM_UPPERCASE, length).commit();
            updatePolicies();
        }

        void setPasswordMinimumLowercase(int length) {
            SharedPreferences prefs = getSamplePreferences(this);
            prefs.edit().putInt(PREF_PASSWORD_MINIMUM_LOWERCASE, length).commit();
            updatePolicies();
        }

        void setPasswordMinimumNumeric(int length) {
            SharedPreferences prefs = getSamplePreferences(this);
            prefs.edit().putInt(PREF_PASSWORD_MINIMUM_NUMERIC, length).commit();
            updatePolicies();
        }

        void setPasswordMinimumSymbols(int length) {
            SharedPreferences prefs = getSamplePreferences(this);
            prefs.edit().putInt(PREF_PASSWORD_MINIMUM_SYMBOLS, length).commit();
            updatePolicies();
        }

        void setPasswordMinimumNonLetter(int length) {
            SharedPreferences prefs = getSamplePreferences(this);
            prefs.edit().putInt(PREF_PASSWORD_MINIMUM_NONLETTER, length).commit();
            updatePolicies();
        }

        void setPasswordHistoryLength(int length) {
            SharedPreferences prefs = getSamplePreferences(this);
            prefs.edit().putInt(PREF_PASSWORD_HISTORY_LENGTH, length).commit();
            updatePolicies();
        }

        void setPasswordExpiration(long expiration) {
            SharedPreferences prefs = getSamplePreferences(this);
            long exp = expiration * MS_PER_MINUTE; // convert from UI units to ms
            prefs.edit().putLong(PREF_PASSWORD_EXPIRATION_TIMEOUT, exp).commit();
            updatePolicies();
            // Show confirmation dialog
            long confirm = mDPM.getPasswordExpiration(mDeviceAdminSample);
            String date = DateFormat.getDateTimeInstance(DateFormat.DEFAULT, DateFormat.DEFAULT)
                    .format(new Date(confirm));
            new AlertDialog.Builder(this)
                    .setMessage("Password will expire on " + date)
                    .setPositiveButton("OK", null)
                    .create()
                    .show();
        }

        void setMaxFailedPw(int length) {
            SharedPreferences prefs = getSamplePreferences(this);
            prefs.edit().putInt(PREF_MAX_FAILED_PW, length).commit();
            updatePolicies();
        }

        @Override
        protected void onResume() {
            super.onResume();
            updateButtonStates();
            updatePasswordExpirationStatus();
        }

        @Override
        protected void onActivityResult(int requestCode, int resultCode, Intent data) {
            switch (requestCode) {
                case REQUEST_CODE_ENABLE_ADMIN:
                    if (resultCode == Activity.RESULT_OK) {
                        Log.i(TAG, "Admin enabled!");
                    } else {
                        Log.i(TAG, "Admin enable FAILED!");
                    }
                    return;
                case REQUEST_CODE_START_ENCRYPTION:
                    updateEncryptionStatus();
                    return;
            }

            super.onActivityResult(requestCode, resultCode, data);
        }

        private OnClickListener mEnableListener = new OnClickListener() {
            public void onClick(View v) {
                // Launch the activity to have the user enable our admin.
                Intent intent = new Intent(DevicePolicyManager.ACTION_ADD_DEVICE_ADMIN);
                intent.putExtra(DevicePolicyManager.EXTRA_DEVICE_ADMIN,
                        mDeviceAdminSample);
                intent.putExtra(DevicePolicyManager.EXTRA_ADD_EXPLANATION,
                        "Additional text explaining why this needs to be added.");
                startActivityForResult(intent, REQUEST_CODE_ENABLE_ADMIN);
            }
        };

        private OnClickListener mDisableListener = new OnClickListener() {
            public void onClick(View v) {
                mDPM.removeActiveAdmin(mDeviceAdminSample);
                updateButtonStates();
            }
        };

        private OnClickListener mSetPasswordListener = new OnClickListener() {
            public void onClick(View v) {
                // Launch the activity to have the user set a new password.
                Intent intent = new Intent(DevicePolicyManager.ACTION_SET_NEW_PASSWORD);
                startActivity(intent);
            }
        };

        private OnClickListener mResetPasswordListener = new OnClickListener() {
            public void onClick(View v) {
                if (ActivityManager.isUserAMonkey()) {
                    // Don't trust monkeys to do the right thing!
                    AlertDialog.Builder builder = new AlertDialog.Builder(Controller.this);
                    builder.setMessage("You can't reset my password because you are a monkey!");
                    builder.setPositiveButton("I admit defeat", null);
                    builder.show();
                    return;
                }
                boolean active = mDPM.isAdminActive(mDeviceAdminSample);
                if (active) {
                    mDPM.resetPassword(mPassword.getText().toString(),
                            DevicePolicyManager.RESET_PASSWORD_REQUIRE_ENTRY);
                }
            }
        };

        private OnClickListener mForceLockListener = new OnClickListener() {
            public void onClick(View v) {
                if (ActivityManager.isUserAMonkey()) {
                    // Don't trust monkeys to do the right thing!
                    AlertDialog.Builder builder = new AlertDialog.Builder(Controller.this);
                    builder.setMessage("You can't lock my screen because you are a monkey!");
                    builder.setPositiveButton("I admit defeat", null);
                    builder.show();
                    return;
                }
                boolean active = mDPM.isAdminActive(mDeviceAdminSample);
                if (active) {
                    mDPM.lockNow();
                }
            }
        };

        private OnClickListener mWipeDataListener = new OnClickListener() {
            public void onClick(final View v) {
                if (ActivityManager.isUserAMonkey()) {
                    // Don't trust monkeys to do the right thing!
                    AlertDialog.Builder builder = new AlertDialog.Builder(Controller.this);
                    builder.setMessage("You can't wipe my data because you are a monkey!");
                    builder.setPositiveButton("I admit defeat", null);
                    builder.show();
                    return;
                }
                AlertDialog.Builder builder = new AlertDialog.Builder(Controller.this);
                builder.setMessage("This will erase all of your data.  Are you sure?");
                builder.setPositiveButton("Yes", new DialogInterface.OnClickListener() {
                    public void onClick(DialogInterface dialog, int which) {
                        AlertDialog.Builder builder = new AlertDialog.Builder(Controller.this);
                        if (v == mWipeAllDataButton) {
                            builder.setMessage("This is not a test.  "
                                    + "This WILL erase all of your data, "
                                    + "including external storage!  "
                                    + "Are you really absolutely sure?");
                        } else {
                            builder.setMessage("This is not a test.  "
                                    + "This WILL erase all of your data!  "
                                    + "Are you really absolutely sure?");
                        }
                        builder.setPositiveButton("BOOM!", new DialogInterface.OnClickListener() {
                            public void onClick(DialogInterface dialog, int which) {
                                boolean active = mDPM.isAdminActive(mDeviceAdminSample);
                                if (active) {
                                    mDPM.wipeData(v == mWipeAllDataButton
                                            ? DevicePolicyManager.WIPE_EXTERNAL_STORAGE : 0);
                                }
                            }
                        });
                        builder.setNegativeButton("Oops, run away!", null);
                        builder.show();
                    }
                });
                builder.setNegativeButton("No way!", null);
                builder.show();
            }
        };

        private OnClickListener mSetTimeoutListener = new OnClickListener() {

            public void onClick(View v) {
                if (ActivityManager.isUserAMonkey()) {
                    // Don't trust monkeys to do the right thing!
                    AlertDialog.Builder builder = new AlertDialog.Builder(Controller.this);
                    builder.setMessage("You can't lock my screen because you are a monkey!");
                    builder.setPositiveButton("I admit defeat", null);
                    builder.show();
                    return;
                }
                boolean active = mDPM.isAdminActive(mDeviceAdminSample);
                if (active) {
                    long timeMs = 1000L*Long.parseLong(mTimeout.getText().toString());
                    mDPM.setMaximumTimeToLock(mDeviceAdminSample, timeMs);
                }
            }
        };

        private OnClickListener mEncryptionButtonListener = new OnClickListener() {
            public void onClick(View v) {
                int buttonId = v.getId();
                if (buttonId == R.id.encryption_enable_button) {
                    mDPM.setStorageEncryption(mDeviceAdminSample, true);
                } else if (buttonId == R.id.encryption_disable_button) {
                    mDPM.setStorageEncryption(mDeviceAdminSample, false);
                } else if (buttonId == R.id.encryption_activate_button) {
                    if (ActivityManager.isUserAMonkey()) {
                        // Don't trust monkeys to do the right thing!
                        AlertDialog.Builder builder = new AlertDialog.Builder(Controller.this);
                        builder.setMessage("You can't activate encryption, you're a monkey!");
                        builder.setPositiveButton("I admit defeat", null);
                        builder.show();
                        return;
                    }
                    if (mDPM.getStorageEncryptionStatus() ==
                            DevicePolicyManager.ENCRYPTION_STATUS_UNSUPPORTED) {
                        AlertDialog.Builder builder = new AlertDialog.Builder(Controller.this);
                        builder.setMessage("Encryption is unsupported on this device.");
                        builder.setPositiveButton("OK", null);
                        builder.show();
                        return;
                    }
                    // Launch the activity to activate encryption.  May or may not return!
                    Intent intent = new Intent(DevicePolicyManager.ACTION_START_ENCRYPTION);
                    startActivityForResult(intent, REQUEST_CODE_START_ENCRYPTION);
                }

                // In all cases, fall through to update status
                updateEncryptionStatus();
            }
        };

        private void updateEncryptionStatus() {
            boolean sampleAdminStatusValue = mDPM.getStorageEncryption(mDeviceAdminSample);
            String sampleAdminStatus = Boolean.toString(sampleAdminStatusValue);
            boolean adminStatusValue = mDPM.getStorageEncryption(null);
            String adminStatus = Boolean.toString(adminStatusValue);
            int deviceStatusCode = mDPM.getStorageEncryptionStatus();
            String deviceStatus = statusCodeToString(deviceStatusCode);
            mEncryptionStatus.setText("sample:" + sampleAdminStatus + " admins:" + adminStatus
                    + " device:" + deviceStatus);
        }

        private String statusCodeToString(int newStatusCode) {
            String newStatus = "unknown";
            switch (newStatusCode) {
                case DevicePolicyManager.ENCRYPTION_STATUS_UNSUPPORTED:
                    newStatus = "unsupported";
                    break;
                case DevicePolicyManager.ENCRYPTION_STATUS_INACTIVE:
                    newStatus = "inactive";
                    break;
                case DevicePolicyManager.ENCRYPTION_STATUS_ACTIVATING:
                    newStatus = "activating";
                    break;
                case DevicePolicyManager.ENCRYPTION_STATUS_ACTIVE:
                    newStatus = "active";
                    break;
            }
            return newStatus;
        }
    }
}

Lock the Android phone with a password

2011-07-12T06:40:00.000-07:00

KeyguardManager mgr = (KeyguardManager)getSystemService(Activity.KEYGUARD_SERVICE);KeyguardLock lock = mgr.newKeyguardLock(KEYGUARD_SERVICE);


lock.reenableKeyguard();

android.permission.DISABLE_KEYGUARD

Lock the Android phone with a password

2011-07-12T06:38:00.000-07:00

public class

DevicePolicyManager

extends Object

java.lang.Object
↳	android.app.admin.DevicePolicyManager

Class Overview

Public interface for managing policies enforced on a device. Most clients of this class must have published a DeviceAdminReceiver that the user has currently enabled.

Summary

Constants
String	ACTION_ADD_DEVICE_ADMIN	Activity action: ask the user to add a new device administrator to the system.
String	ACTION_SET_NEW_PASSWORD	Activity action: have the user enter a new password.
String	ACTION_START_ENCRYPTION	Activity action: begin the process of encrypting data on the device.
int	ENCRYPTION_STATUS_ACTIVATING	Result code for `setStorageEncryption(ComponentName, boolean)` and`getStorageEncryptionStatus()`: indicating that encryption is not currently active, but is currently being activated.
int	ENCRYPTION_STATUS_ACTIVE	Result code for `setStorageEncryption(ComponentName, boolean)` and`getStorageEncryptionStatus()`: indicating that encryption is active.
int	ENCRYPTION_STATUS_INACTIVE	Result code for `setStorageEncryption(ComponentName, boolean)` and`getStorageEncryptionStatus()`: indicating that encryption is supported, but is not currently active.
int	ENCRYPTION_STATUS_UNSUPPORTED	Result code for `setStorageEncryption(ComponentName, boolean)` and`getStorageEncryptionStatus()`: indicating that encryption is not supported.
String	EXTRA_ADD_EXPLANATION	An optional CharSequence providing additional explanation for why the admin is being added.
String	EXTRA_DEVICE_ADMIN	The ComponentName of the administrator component.
int	PASSWORD_QUALITY_ALPHABETIC	Constant for `setPasswordQuality(ComponentName, int)`: the user must have entered a password containing at least alphabetic (or other symbol) characters.
int	PASSWORD_QUALITY_ALPHANUMERIC	Constant for `setPasswordQuality(ComponentName, int)`: the user must have entered a password containing at least both> numeric and alphabetic (or other symbol) characters.
int	PASSWORD_QUALITY_COMPLEX	Constant for `setPasswordQuality(ComponentName, int)`: the user must have entered a password containing at least a letter, a numerical digit and a special symbol, by default.
int	PASSWORD_QUALITY_NUMERIC	Constant for `setPasswordQuality(ComponentName, int)`: the user must have entered a password containing at least numeric characters.
int	PASSWORD_QUALITY_SOMETHING	Constant for `setPasswordQuality(ComponentName, int)`: the policy requires some kind of password, but doesn't care what it is.
int	PASSWORD_QUALITY_UNSPECIFIED	Constant for `setPasswordQuality(ComponentName, int)`: the policy has no requirements for the password.
int	RESET_PASSWORD_REQUIRE_ENTRY	Flag for `resetPassword(String, int)`: don't allow other admins to change the password again until the user has entered it.
int	WIPE_EXTERNAL_STORAGE	Flag for `wipeData(int)`: also erase the device's external storage.

Public Methods
List<ComponentName>	getActiveAdmins() Return a list of all currently active device administrator's component names.
int	getCurrentFailedPasswordAttempts() Retrieve the number of times the user has failed at entering a password since that last successful password entry.
int	getMaximumFailedPasswordsForWipe(ComponentName admin) Retrieve the current maximum number of login attempts that are allowed before the device wipes itself, for all admins or a particular one.
long	getMaximumTimeToLock(ComponentName admin) Retrieve the current maximum time to unlock for all admins or a particular one.
long	getPasswordExpiration(ComponentName admin) Get the current password expiration time for the given admin or an aggregate of all admins if admin is null.
long	getPasswordExpirationTimeout(ComponentName admin) Get the password expiration timeout for the given admin.
int	getPasswordHistoryLength(ComponentName admin) Retrieve the current password history length for all admins or a particular one.
int	getPasswordMaximumLength(int quality) Return the maximum password length that the device supports for a particular password quality.
int	getPasswordMinimumLength(ComponentName admin) Retrieve the current minimum password length for all admins or a particular one.
int	getPasswordMinimumLetters(ComponentName admin) Retrieve the current number of letters required in the password for all admins or a particular one.
int	getPasswordMinimumLowerCase(ComponentName admin) Retrieve the current number of lower case letters required in the password for all admins or a particular one.
int	getPasswordMinimumNonLetter(ComponentName admin) Retrieve the current number of non-letter characters required in the password for all admins or a particular one.
int	getPasswordMinimumNumeric(ComponentName admin) Retrieve the current number of numerical digits required in the password for all admins or a particular one.
int	getPasswordMinimumSymbols(ComponentName admin) Retrieve the current number of symbols required in the password for all admins or a particular one.
int	getPasswordMinimumUpperCase(ComponentName admin) Retrieve the current number of upper case letters required in the password for all admins or a particular one.
int	getPasswordQuality(ComponentName admin) Retrieve the current minimum password quality for all admins or a particular one.
boolean	getStorageEncryption(ComponentName admin) Called by an application that is administering the device to determine the requested setting for secure storage.
int	getStorageEncryptionStatus() Called by an application that is administering the device to determine the current encryption status of the device.
boolean	hasGrantedPolicy(ComponentName admin, int usesPolicy) Returns true if an administrator has been granted a particular device policy.
boolean	isActivePasswordSufficient() Determine whether the current password the user has set is sufficient to meet the policy requirements (quality, minimum length) that have been requested.
boolean	isAdminActive(ComponentName who) Return true if the given administrator component is currently active (enabled) in the system.
void	lockNow() Make the device lock immediately, as if the lock screen timeout has expired at the point of this call.
void	removeActiveAdmin(ComponentName who) Remove a current administration component.
boolean	resetPassword(String password, int flags) Force a new device unlock password (the password needed to access the entire device, not for individual accounts) on the user.
void	setMaximumFailedPasswordsForWipe(ComponentName admin, int num) Setting this to a value greater than zero enables a built-in policy that will perform a device wipe after too many incorrect device-unlock passwords have been entered.
void	setMaximumTimeToLock(ComponentName admin, long timeMs) Called by an application that is administering the device to set the maximum time for user activity until the device will lock.
void	setPasswordExpirationTimeout(ComponentName admin, long timeout) Called by a device admin to set the password expiration timeout.
void	setPasswordHistoryLength(ComponentName admin, int length) Called by an application that is administering the device to set the length of the password history.
void	setPasswordMinimumLength(ComponentName admin, int length) Called by an application that is administering the device to set the minimum allowed password length.
void	setPasswordMinimumLetters(ComponentName admin, int length) Called by an application that is administering the device to set the minimum number of letters required in the password.
void	setPasswordMinimumLowerCase(ComponentName admin, int length) Called by an application that is administering the device to set the minimum number of lower case letters required in the password.
void	setPasswordMinimumNonLetter(ComponentName admin, int length) Called by an application that is administering the device to set the minimum number of non-letter characters (numerical digits or symbols) required in the password.
void	setPasswordMinimumNumeric(ComponentName admin, int length) Called by an application that is administering the device to set the minimum number of numerical digits required in the password.
void	setPasswordMinimumSymbols(ComponentName admin, int length) Called by an application that is administering the device to set the minimum number of symbols required in the password.
void	setPasswordMinimumUpperCase(ComponentName admin, int length) Called by an application that is administering the device to set the minimum number of upper case letters required in the password.
void	setPasswordQuality(ComponentName admin, int quality) Called by an application that is administering the device to set the password restrictions it is imposing.
int	setStorageEncryption(ComponentName admin, boolean encrypt) Called by an application that is administering the device to request that the storage system be encrypted.
void	wipeData(int flags) Ask the user date be wiped.

[Expand] Inherited Methods
From class java.lang.Object

Constants

public static final String ACTION_ADD_DEVICE_ADMIN

Since: API Level 8

Activity action: ask the user to add a new device administrator to the system. The desired policy is the ComponentName of the policy in the EXTRA_DEVICE_ADMINextra field. This will invoke a UI to bring the user through adding the device administrator to the system (or allowing them to reject it).

You can optionally include the EXTRA_ADD_EXPLANATION field to provide the user with additional explanation (in addition to your component's description) about what is being added.

If your administrator is already active, this will ordinarily return immediately (without user intervention). However, if your administrator has been updated and is requesting additional uses-policy flags, the user will be presented with the new list. New policies will not be available to the updated administrator until the user has accepted the new list.

Constant Value: "android.app.action.ADD_DEVICE_ADMIN"

public static final String ACTION_SET_NEW_PASSWORD

Since: API Level 8

Activity action: have the user enter a new password. This activity should be launched after using setPasswordQuality(ComponentName, int), orsetPasswordMinimumLength(ComponentName, int) to have the user enter a new password that meets the current requirements. You can useisActivePasswordSufficient() to determine whether you need to have the user select a new password in order to meet the current constraints. Upon being resumed from this activity, you can check the new password characteristics to see if they are sufficient.

Constant Value: "android.app.action.SET_NEW_PASSWORD"

public static final String ACTION_START_ENCRYPTION

Since: API Level 11

Activity action: begin the process of encrypting data on the device. This activity should be launched after using setStorageEncryption(ComponentName, boolean) to request encryption be activated. After resuming from this activity, use getStorageEncryption(ComponentName) to check encryption status. However, on some devices this activity may never return, as it may trigger a reboot and in some cases a complete data wipe of the device.

Constant Value: "android.app.action.START_ENCRYPTION"

public static final int ENCRYPTION_STATUS_ACTIVATING

Since: API Level 11

Result code for setStorageEncryption(ComponentName, boolean) and getStorageEncryptionStatus(): indicating that encryption is not currently active, but is currently being activated. This is only reported by devices that support encryption of data and only when the storage is currently undergoing a process of becoming encrypted. A device that must reboot and/or wipe data to become encrypted will never return this value.

Constant Value: 2 (0x00000002)

public static final int ENCRYPTION_STATUS_ACTIVE

Since: API Level 11

Result code for setStorageEncryption(ComponentName, boolean) and getStorageEncryptionStatus(): indicating that encryption is active.

Constant Value: 3 (0x00000003)

public static final int ENCRYPTION_STATUS_INACTIVE

Since: API Level 11

Result code for setStorageEncryption(ComponentName, boolean) and getStorageEncryptionStatus(): indicating that encryption is supported, but is not currently active.

Constant Value: 1 (0x00000001)

public static final int ENCRYPTION_STATUS_UNSUPPORTED

Since: API Level 11

Result code for setStorageEncryption(ComponentName, boolean) and getStorageEncryptionStatus(): indicating that encryption is not supported.

Constant Value: 0 (0x00000000)

public static final String EXTRA_ADD_EXPLANATION

Since: API Level 8

An optional CharSequence providing additional explanation for why the admin is being added.

public static final String EXTRA_DEVICE_ADMIN

Since: API Level 8

The ComponentName of the administrator component.

public static final int PASSWORD_QUALITY_ALPHABETIC

Since: API Level 8

Constant for setPasswordQuality(ComponentName, int): the user must have entered a password containing at least alphabetic (or other symbol) characters. Note that quality constants are ordered so that higher values are more restrictive.

Constant Value: 262144 (0x00040000)

public static final int PASSWORD_QUALITY_ALPHANUMERIC

Since: API Level 8

Constant for setPasswordQuality(ComponentName, int): the user must have entered a password containing at least both> numeric and alphabetic (or other symbol) characters. Note that quality constants are ordered so that higher values are more restrictive.

Constant Value: 327680 (0x00050000)

public static final int PASSWORD_QUALITY_COMPLEX

Since: API Level 11

Constant for setPasswordQuality(ComponentName, int): the user must have entered a password containing at least a letter, a numerical digit and a special symbol, by default. With this password quality, passwords can be restricted to contain various sets of characters, like at least an uppercase letter, etc. These are specified using various methods, like setPasswordMinimumLowerCase(ComponentName, int). Note that quality constants are ordered so that higher values are more restrictive.

Constant Value: 393216 (0x00060000)

public static final int PASSWORD_QUALITY_NUMERIC

Since: API Level 8

Constant for setPasswordQuality(ComponentName, int): the user must have entered a password containing at least numeric characters. Note that quality constants are ordered so that higher values are more restrictive.

Constant Value: 131072 (0x00020000)

public static final int PASSWORD_QUALITY_SOMETHING

Since: API Level 8

Constant for setPasswordQuality(ComponentName, int): the policy requires some kind of password, but doesn't care what it is. Note that quality constants are ordered so that higher values are more restrictive.

Constant Value: 65536 (0x00010000)

public static final int PASSWORD_QUALITY_UNSPECIFIED

Since: API Level 8

Constant for setPasswordQuality(ComponentName, int): the policy has no requirements for the password. Note that quality constants are ordered so that higher values are more restrictive.

Constant Value: 0 (0x00000000)

public static final int RESET_PASSWORD_REQUIRE_ENTRY

Since: API Level 8

Flag for resetPassword(String, int): don't allow other admins to change the password again until the user has entered it.

Constant Value: 1 (0x00000001)

public static final int WIPE_EXTERNAL_STORAGE

Since: API Level 9

Flag for wipeData(int): also erase the device's external storage.

Constant Value: 1 (0x00000001)

Public Methods

public List<ComponentName> getActiveAdmins ()

Since: API Level 8

Return a list of all currently active device administrator's component names. Note that if there are no administrators than null may be returned.

public int getCurrentFailedPasswordAttempts ()

Since: API Level 8

Retrieve the number of times the user has failed at entering a password since that last successful password entry.

The calling device admin must have requested USES_POLICY_WATCH_LOGIN to be able to call this method; if it has not, a security exception will be thrown.

public int getMaximumFailedPasswordsForWipe (ComponentName admin)

Since: API Level 8

Retrieve the current maximum number of login attempts that are allowed before the device wipes itself, for all admins or a particular one.

Parameters

admin	The name of the admin component to check, or null to aggregate all admins.

public long getMaximumTimeToLock (ComponentName admin)

Since: API Level 8

Retrieve the current maximum time to unlock for all admins or a particular one.

Parameters

admin	The name of the admin component to check, or null to aggregate all admins.

public long getPasswordExpiration (ComponentName admin)

Since: API Level 11

Get the current password expiration time for the given admin or an aggregate of all admins if admin is null. If the password is expired, this will return the time since the password expired as a negative number. If admin is null, then a composite of all expiration timeouts is returned - which will be the minimum of all timeouts.

Parameters

admin	The name of the admin component to check, or null to aggregate all admins.

Returns

The password expiration time, in ms.

public long getPasswordExpirationTimeout (ComponentName admin)

Since: API Level 11

Get the password expiration timeout for the given admin. The expiration timeout is the recurring expiration timeout provided in the call tosetPasswordExpirationTimeout(ComponentName, long) for the given admin or the aggregate of all policy administrators if admin is null.

Parameters

admin	The name of the admin component to check, or null to aggregate all admins.

Returns

The timeout for the given admin or the minimum of all timeouts

public int getPasswordHistoryLength (ComponentName admin)

Since: API Level 11

Retrieve the current password history length for all admins or a particular one.

Parameters

admin	The name of the admin component to check, or null to aggregate all admins.

Returns

The length of the password history

public int getPasswordMaximumLength (int quality)

Since: API Level 8

Return the maximum password length that the device supports for a particular password quality.

Parameters

quality	The quality being interrogated.

Returns

Returns the maximum length that the user can enter.

public int getPasswordMinimumLength (ComponentName admin)

Since: API Level 8

Retrieve the current minimum password length for all admins or a particular one.

Parameters

admin	The name of the admin component to check, or null to aggregate all admins.

public int getPasswordMinimumLetters (ComponentName admin)

Since: API Level 11

Retrieve the current number of letters required in the password for all admins or a particular one. This is the same value as set by {#linksetPasswordMinimumLetters(ComponentName, int) and only applies when the password quality is PASSWORD_QUALITY_COMPLEX.

Parameters

admin	The name of the admin component to check, or null to aggregate all admins.

Returns

The minimum number of letters required in the password.

public int getPasswordMinimumLowerCase (ComponentName admin)

Since: API Level 11

Retrieve the current number of lower case letters required in the password for all admins or a particular one. This is the same value as set by {#linksetPasswordMinimumLowerCase(ComponentName, int) and only applies when the password quality is PASSWORD_QUALITY_COMPLEX.

Parameters

admin	The name of the admin component to check, or null to aggregate all admins.

Returns

The minimum number of lower case letters required in the password.

public int getPasswordMinimumNonLetter (ComponentName admin)

Since: API Level 11

Retrieve the current number of non-letter characters required in the password for all admins or a particular one. This is the same value as set by {#linksetPasswordMinimumNonLetter(ComponentName, int) and only applies when the password quality is PASSWORD_QUALITY_COMPLEX.

Parameters

admin	The name of the admin component to check, or null to aggregate all admins.

Returns

The minimum number of letters required in the password.

public int getPasswordMinimumNumeric (ComponentName admin)

Since: API Level 11

Retrieve the current number of numerical digits required in the password for all admins or a particular one. This is the same value as set by {#linksetPasswordMinimumNumeric(ComponentName, int) and only applies when the password quality is PASSWORD_QUALITY_COMPLEX.

Parameters

admin	The name of the admin component to check, or null to aggregate all admins.

Returns

The minimum number of numerical digits required in the password.

public int getPasswordMinimumSymbols (ComponentName admin)

Since: API Level 11

Retrieve the current number of symbols required in the password for all admins or a particular one. This is the same value as set by {#linksetPasswordMinimumSymbols(ComponentName, int) and only applies when the password quality is PASSWORD_QUALITY_COMPLEX.

Parameters

admin	The name of the admin component to check, or null to aggregate all admins.

Returns

The minimum number of symbols required in the password.

public int getPasswordMinimumUpperCase (ComponentName admin)

Since: API Level 11

Retrieve the current number of upper case letters required in the password for all admins or a particular one. This is the same value as set by {#linksetPasswordMinimumUpperCase(ComponentName, int) and only applies when the password quality is PASSWORD_QUALITY_COMPLEX.

Parameters

admin	The name of the admin component to check, or null to aggregate all admins.

Returns

The minimum number of upper case letters required in the password.

public int getPasswordQuality (ComponentName admin)

Since: API Level 8

Retrieve the current minimum password quality for all admins or a particular one.

Parameters

admin	The name of the admin component to check, or null to aggregate all admins.

public boolean getStorageEncryption (ComponentName admin)

Since: API Level 11

Called by an application that is administering the device to determine the requested setting for secure storage.

Parameters

admin	Which `DeviceAdminReceiver` this request is associated with. If null, this will return the requested encryption setting as an aggregate of all active administrators.

Returns

true if the admin(s) are requesting encryption, false if not.

public int getStorageEncryptionStatus ()

Since: API Level 11

Called by an application that is administering the device to determine the current encryption status of the device. Depending on the returned status code, the caller may proceed in different ways. If the result is ENCRYPTION_STATUS_UNSUPPORTED, the storage system does not support encryption. If the result isENCRYPTION_STATUS_INACTIVE, use ACTION_START_ENCRYPTION to begin the process of encrypting or decrypting the storage. If the result isENCRYPTION_STATUS_ACTIVATING or ENCRYPTION_STATUS_ACTIVE, no further action is required.

Returns

current status of encryption. The value will be one of ENCRYPTION_STATUS_UNSUPPORTED, ENCRYPTION_STATUS_INACTIVE,ENCRYPTION_STATUS_ACTIVATING, orENCRYPTION_STATUS_ACTIVE.

public boolean hasGrantedPolicy (ComponentName admin, int usesPolicy)

Since: API Level 11

Returns true if an administrator has been granted a particular device policy. This can be used to check if the administrator was activated under an earlier set of policies, but requires additional policies after an upgrade.

Parameters

admin	Which `DeviceAdminReceiver` this request is associated with. Must be an active administrator, or an exception will be thrown.
usesPolicy	Which uses-policy to check, as defined in `DeviceAdminInfo`.

public boolean isActivePasswordSufficient ()

Since: API Level 8

Determine whether the current password the user has set is sufficient to meet the policy requirements (quality, minimum length) that have been requested.

The calling device admin must have requested USES_POLICY_LIMIT_PASSWORD to be able to call this method; if it has not, a security exception will be thrown.

Returns

Returns true if the password meets the current requirements, else false.

public boolean isAdminActive (ComponentName who)

Since: API Level 8

Return true if the given administrator component is currently active (enabled) in the system.

public void lockNow ()

Since: API Level 8

Make the device lock immediately, as if the lock screen timeout has expired at the point of this call.

The calling device admin must have requested USES_POLICY_FORCE_LOCK to be able to call this method; if it has not, a security exception will be thrown.

public void removeActiveAdmin (ComponentName who)

Since: API Level 8

Remove a current administration component. This can only be called by the application that owns the administration component; if you try to remove someone else's component, a security exception will be thrown.

public boolean resetPassword (String password, int flags)

Since: API Level 8

Force a new device unlock password (the password needed to access the entire device, not for individual accounts) on the user. This takes effect immediately. The given password must be sufficient for the current password quality and length constraints as returned by getPasswordQuality(ComponentName) andgetPasswordMinimumLength(ComponentName); if it does not meet these constraints, then it will be rejected and false returned. Note that the password may be a stronger quality (containing alphanumeric characters when the requested quality is only numeric), in which case the currently active quality will be increased to match.

The calling device admin must have requested USES_POLICY_RESET_PASSWORD to be able to call this method; if it has not, a security exception will be thrown.

Parameters

password	The new password for the user.
flags	May be 0 or `RESET_PASSWORD_REQUIRE_ENTRY`.

Returns

Returns true if the password was applied, or false if it is not acceptable for the current constraints.

public void setMaximumFailedPasswordsForWipe (ComponentName admin, int num)

Since: API Level 8

Setting this to a value greater than zero enables a built-in policy that will perform a device wipe after too many incorrect device-unlock passwords have been entered. This built-in policy combines watching for failed passwords and wiping the device, and requires that you request both USES_POLICY_WATCH_LOGIN andUSES_POLICY_WIPE_DATA}.

To implement any other policy (e.g. wiping data for a particular application only, erasing or revoking credentials, or reporting the failure to a server), you should implementonPasswordFailed(Context, android.content.Intent) instead. Do not use this API, because if the maximum count is reached, the device will be wiped immediately, and your callback will not be invoked.

Parameters

admin	Which `DeviceAdminReceiver` this request is associated with.
num	The number of failed password attempts at which point the device will wipe its data.

public void setMaximumTimeToLock (ComponentName admin, long timeMs)

Since: API Level 8

Called by an application that is administering the device to set the maximum time for user activity until the device will lock. This limits the length that the user can set. It takes effect immediately.

The calling device admin must have requested USES_POLICY_FORCE_LOCK to be able to call this method; if it has not, a security exception will be thrown.

Parameters

admin	Which `DeviceAdminReceiver` this request is associated with.
timeMs	The new desired maximum time to lock in milliseconds. A value of 0 means there is no restriction.

public void setPasswordExpirationTimeout (ComponentName admin, long timeout)

Since: API Level 11

Called by a device admin to set the password expiration timeout. Calling this method will restart the countdown for password expiration for the given admin, as will changing the device password (for all admins).

The provided timeout is the time delta in ms and will be added to the current time. For example, to have the password expire 5 days from now, timeout would be 5 * 86400 * 1000 = 432000000 ms for timeout.

To disable password expiration, a value of 0 may be used for timeout.

The calling device admin must have requested USES_POLICY_EXPIRE_PASSWORD to be able to call this method; if it has not, a security exception will be thrown.

Parameters

admin	Which `DeviceAdminReceiver` this request is associated with.
timeout	The limit (in ms) that a password can remain in effect. A value of 0 means there is no restriction (unlimited).

public void setPasswordHistoryLength (ComponentName admin, int length)

Since: API Level 11

Called by an application that is administering the device to set the length of the password history. After setting this, the user will not be able to enter a new password that is the same as any password in the history. Note that the current password will remain until the user has set a new one, so the change does not take place immediately. To prompt the user for a new password, use ACTION_SET_NEW_PASSWORD after setting this value. This constraint is only imposed if the administrator has also requested either PASSWORD_QUALITY_NUMERIC, PASSWORD_QUALITY_ALPHABETIC, or PASSWORD_QUALITY_ALPHANUMERIC withsetPasswordQuality(ComponentName, int).

The calling device admin must have requested USES_POLICY_LIMIT_PASSWORD to be able to call this method; if it has not, a security exception will be thrown.

Parameters

admin	Which `DeviceAdminReceiver` this request is associated with.
length	The new desired length of password history. A value of 0 means there is no restriction.

public void setPasswordMinimumLength (ComponentName admin, int length)

Since: API Level 8

Called by an application that is administering the device to set the minimum allowed password length. After setting this, the user will not be able to enter a new password that is not at least as restrictive as what has been set. Note that the current password will remain until the user has set a new one, so the change does not take place immediately. To prompt the user for a new password, use ACTION_SET_NEW_PASSWORD after setting this value. This constraint is only imposed if the administrator has also requested either PASSWORD_QUALITY_NUMERIC, PASSWORD_QUALITY_ALPHABETIC PASSWORD_QUALITY_ALPHANUMERIC, orPASSWORD_QUALITY_COMPLEX with setPasswordQuality(ComponentName, int).

The calling device admin must have requested USES_POLICY_LIMIT_PASSWORD to be able to call this method; if it has not, a security exception will be thrown.

Parameters

admin	Which `DeviceAdminReceiver` this request is associated with.
length	The new desired minimum password length. A value of 0 means there is no restriction.

public void setPasswordMinimumLetters (ComponentName admin, int length)

Since: API Level 11

Called by an application that is administering the device to set the minimum number of letters required in the password. After setting this, the user will not be able to enter a new password that is not at least as restrictive as what has been set. Note that the current password will remain until the user has set a new one, so the change does not take place immediately. To prompt the user for a new password, use ACTION_SET_NEW_PASSWORD after setting this value. This constraint is only imposed if the administrator has also requested PASSWORD_QUALITY_COMPLEX with setPasswordQuality(ComponentName, int). The default value is 1.

The calling device admin must have requested USES_POLICY_LIMIT_PASSWORD to be able to call this method; if it has not, a security exception will be thrown.

Parameters

admin	Which `DeviceAdminReceiver` this request is associated with.
length	The new desired minimum number of letters required in the password. A value of 0 means there is no restriction.

public void setPasswordMinimumLowerCase (ComponentName admin, int length)

Since: API Level 11

Called by an application that is administering the device to set the minimum number of lower case letters required in the password. After setting this, the user will not be able to enter a new password that is not at least as restrictive as what has been set. Note that the current password will remain until the user has set a new one, so the change does not take place immediately. To prompt the user for a new password, use ACTION_SET_NEW_PASSWORD after setting this value. This constraint is only imposed if the administrator has also requested PASSWORD_QUALITY_COMPLEX with setPasswordQuality(ComponentName, int). The default value is 0.

The calling device admin must have requested USES_POLICY_LIMIT_PASSWORD to be able to call this method; if it has not, a security exception will be thrown.

Parameters

admin	Which `DeviceAdminReceiver` this request is associated with.
length	The new desired minimum number of lower case letters required in the password. A value of 0 means there is no restriction.

public void setPasswordMinimumNonLetter (ComponentName admin, int length)

Since: API Level 11

Called by an application that is administering the device to set the minimum number of non-letter characters (numerical digits or symbols) required in the password. After setting this, the user will not be able to enter a new password that is not at least as restrictive as what has been set. Note that the current password will remain until the user has set a new one, so the change does not take place immediately. To prompt the user for a new password, use ACTION_SET_NEW_PASSWORD after setting this value. This constraint is only imposed if the administrator has also requested PASSWORD_QUALITY_COMPLEX with setPasswordQuality(ComponentName, int). The default value is 0.

The calling device admin must have requested USES_POLICY_LIMIT_PASSWORD to be able to call this method; if it has not, a security exception will be thrown.

Parameters

admin	Which `DeviceAdminReceiver` this request is associated with.
length	The new desired minimum number of letters required in the password. A value of 0 means there is no restriction.

public void setPasswordMinimumNumeric (ComponentName admin, int length)

Since: API Level 11

Called by an application that is administering the device to set the minimum number of numerical digits required in the password. After setting this, the user will not be able to enter a new password that is not at least as restrictive as what has been set. Note that the current password will remain until the user has set a new one, so the change does not take place immediately. To prompt the user for a new password, use ACTION_SET_NEW_PASSWORD after setting this value. This constraint is only imposed if the administrator has also requested PASSWORD_QUALITY_COMPLEX with setPasswordQuality(ComponentName, int). The default value is 1.

The calling device admin must have requested USES_POLICY_LIMIT_PASSWORD to be able to call this method; if it has not, a security exception will be thrown.

Parameters

admin	Which `DeviceAdminReceiver` this request is associated with.
length	The new desired minimum number of numerical digits required in the password. A value of 0 means there is no restriction.

public void setPasswordMinimumSymbols (ComponentName admin, int length)

Since: API Level 11

Called by an application that is administering the device to set the minimum number of symbols required in the password. After setting this, the user will not be able to enter a new password that is not at least as restrictive as what has been set. Note that the current password will remain until the user has set a new one, so the change does not take place immediately. To prompt the user for a new password, use ACTION_SET_NEW_PASSWORD after setting this value. This constraint is only imposed if the administrator has also requested PASSWORD_QUALITY_COMPLEX with setPasswordQuality(ComponentName, int). The default value is 1.

The calling device admin must have requested USES_POLICY_LIMIT_PASSWORD to be able to call this method; if it has not, a security exception will be thrown.

Parameters

admin	Which `DeviceAdminReceiver` this request is associated with.
length	The new desired minimum number of symbols required in the password. A value of 0 means there is no restriction.

public void setPasswordMinimumUpperCase (ComponentName admin, int length)

Since: API Level 11

Called by an application that is administering the device to set the minimum number of upper case letters required in the password. After setting this, the user will not be able to enter a new password that is not at least as restrictive as what has been set. Note that the current password will remain until the user has set a new one, so the change does not take place immediately. To prompt the user for a new password, use ACTION_SET_NEW_PASSWORD after setting this value. This constraint is only imposed if the administrator has also requested PASSWORD_QUALITY_COMPLEX with setPasswordQuality(ComponentName, int). The default value is 0.

The calling device admin must have requested USES_POLICY_LIMIT_PASSWORD to be able to call this method; if it has not, a security exception will be thrown.

Parameters

admin	Which `DeviceAdminReceiver` this request is associated with.
length	The new desired minimum number of upper case letters required in the password. A value of 0 means there is no restriction.

public void setPasswordQuality (ComponentName admin, int quality)

Since: API Level 8

Called by an application that is administering the device to set the password restrictions it is imposing. After setting this, the user will not be able to enter a new password that is not at least as restrictive as what has been set. Note that the current password will remain until the user has set a new one, so the change does not take place immediately. To prompt the user for a new password, use ACTION_SET_NEW_PASSWORD after setting this value.

Quality constants are ordered so that higher values are more restrictive; thus the highest requested quality constant (between the policy set here, the user's preference, and any other considerations) is the one that is in effect.

The calling device admin must have requested USES_POLICY_LIMIT_PASSWORD to be able to call this method; if it has not, a security exception will be thrown.

Parameters

admin	Which `DeviceAdminReceiver` this request is associated with.
quality	The new desired quality. One of `PASSWORD_QUALITY_UNSPECIFIED`, `PASSWORD_QUALITY_SOMETHING`, `PASSWORD_QUALITY_NUMERIC`,`PASSWORD_QUALITY_ALPHABETIC`, `PASSWORD_QUALITY_ALPHANUMERIC` or `PASSWORD_QUALITY_COMPLEX`.

public int setStorageEncryption (ComponentName admin, boolean encrypt)

Since: API Level 11

Called by an application that is administering the device to request that the storage system be encrypted.

When multiple device administrators attempt to control device encryption, the most secure, supported setting will always be used. If any device administrator requests device encryption, it will be enabled; Conversely, if a device administrator attempts to disable device encryption while another device administrator has enabled it, the call to disable will fail (most commonly returning ENCRYPTION_STATUS_ACTIVE).

This policy controls encryption of the secure (application data) storage area. Data written to other storage areas may or may not be encrypted, and this policy does not require or control the encryption of any other storage areas. There is one exception: If isExternalStorageEmulated() is true, then the directory returned bygetExternalStorageDirectory() must be written to disk within the encrypted storage area.

Important Note: On some devices, it is possible to encrypt storage without requiring the user to create a device PIN or Password. In this case, the storage is encrypted, but the encryption key may not be fully secured. For maximum security, the administrator should also require (and check for) a pattern, PIN, or password.

Parameters

admin	Which `DeviceAdminReceiver` this request is associated with.
encrypt	true to request encryption, false to release any previous request

Returns

the new request status (for all active admins) - will be one of ENCRYPTION_STATUS_UNSUPPORTED, ENCRYPTION_STATUS_INACTIVE, orENCRYPTION_STATUS_ACTIVE. This is the value of the requests; Use getStorageEncryptionStatus() to query the actual device state.

public void wipeData (int flags)

Since: API Level 8

Ask the user date be wiped. This will cause the device to reboot, erasing all user data while next booting up. External storage such as SD cards will not be erased.

The calling device admin must have requested USES_POLICY_WIPE_DATA to be able to call this method; if it has not, a security exception will be thrown.

Parameters

flags	Bit mask of additional options: currently must be 0.

IT2s pure Enterprise grade

2011-07-10T23:33:00.000-07:00

CISCO CIUD
http://www.cisco.com/web/products/cius/index.html?CAMPAIGN=cius+for+work&COUNTRY_SITE=us&POSITION=3rd+party+banner&REFERRING_SITE=twitter&CREATIVE=Sponsored+Trend

Android WIFI Connection Status & Disable WIFI

2011-07-06T05:06:00.000-07:00

Check Connection Status

ConnectivityManager connec = (ConnectivityManager)getSystemService(Context.CONNECTIVITY_SERVICE);
// ARE WE CONNECTED TO THE NET
if ( connec.getNetworkInfo(0).getState() == NetworkInfo.State.CONNECTED ||
  connec.getNetworkInfo(1).getState() == NetworkInfo.State.CONNECTED ) {
  // ...
}

Disable WIFI

connec.getNetworkInfo(0).setState(NetworkInfo.State.DISCONNECTED);

WifiManager wifiManager = (WifiManager)this.context.getSystemService(Context.WIFI_SERVICE);
wifiManager.setWifiEnabled(status);

The permissions
<uses-permission android:name="android.permission.ACCESS_WIFI_STATE"></uses-permission>
<uses-permission android:name="android.permission.UPDATE_DEVICE_STATS"></uses-permission>
<uses-permission android:name="android.permission.CHANGE_WIFI_STATE"></uses-permission>

SPARQL Query Language for RDF

2011-07-06T04:26:00.000-07:00

RDF is a directed, labeled graph data format for representing information in the Web. This specification defines the syntax and semantics of the SPARQL query language for RDF. SPARQL can be used to express queries across diverse data sources, whether the data is stored natively as RDF or viewed as RDF via middleware. SPARQL contains capabilities for querying required and optional graph patterns along with their conjunctions and disjunctions. SPARQL also supports extensible value testing and constraining queries by source RDF graph. The results of SPARQL queries can be results sets or RDF graphs.

WSO2 product cluster with registry replication in Oracle

2011-07-04T23:14:00.000-07:00

I recently notice an obvious mistake users doing when they configure WSO2 product cluster and use WSO2 G-Reg as the central repository for the replication among the cluster nodes. You can find a guide on how to set this up in an WSO2 Oxygen Tank tutorial [1] and there we are using Oracle as the database.

If you go through this you will see we are doing two registry mountings in all the cluster nodes, so every cluster node is having two database configuration, one for the local registry database configuration and one for the mount registry database configuration (configuration of the central registry database).

When it comes to Oracle, normally users are using a same database URL and differentiate among different databases by changing the user name and password. This works without any issue, but when it comes to mounting we are referring the URL of the database configuration and we expect you will put different URL values for two database configuration (local registry and config and governance mounting). So with Oracle users will simply not aware of this and use different username password and they get following error.

java.sql.SQLException: Total number of available connections are less than the total number of committed connections

at org.wso2.carbon.registry.core.jdbc.utils.Transaction$ManagedRegistryConnection.commit(Transaction.java:474)

at org.wso2.carbon.registry.core.jdbc.EmbeddedRegistry.commitTransaction(EmbeddedRegistry.java:403)

at org.wso2.carbon.registry.core.jdbc.EmbeddedRegistry.resourceExists(EmbeddedRegistry.java:594)

at org.wso2.carbon.registry.core.session.UserRegistry.resourceExists(UserRegistry.java:545)

at org.wso2.carbon.registry.core.internal.RegistryCoreServiceComponent.setupMounts(RegistryCoreServiceComponent.

java:250)

So this error comes when someone try to mount from it's own database, if you use a configuration like below obviously we are throwing this exception.

<dbConfig name="wso2registry">

<url>jdbc:oracle:thin@qcdvcn1001-vip.dev.rsft.net:15000:DEV541</url>

<userName>wso2_esb</userName>

<password>wso2_esb</password>

<driverName>oracle.jdbc.driver.OracleDriver</driverName>

<maxActive>50</maxActive>

<maxWait>60000</maxWait>

<minIdle>5</minIdle>

</dbConfig>

<dbConfig name="esbMountRegistry">

<url>jdbc:oracle:thin@qcdvcn1001-vip.dev.rsft.net:15000:DEV541</url>

<userName>wso2_greg</userName>

<password>wso2_greg</password>

<driverName>oracle.jdbc.driver.OracleDriver</driverName>

<maxActive>50</maxActive>

<maxWait>60000</maxWait>

<minIdle>5</minIdle>

</dbConfig>

You can see above two URL's are same but username password are different.

So the solution for this issue is differentiate the URL by giving username in the database URL before the "@" sign. So the dbconfig elements of the cluster node registry.xml will looks like this.

<dbConfig name="wso2registry">

<url>jdbc:oracle:thin:wso2_esb@qcdvcn1001-vip.dev.rsft.net:15000:DEV541</url>

<userName>wso2_esb</userName>

<password>wso2_esb</password>

<driverName>oracle.jdbc.driver.OracleDriver</driverName>

<maxActive>50</maxActive>

<maxWait>60000</maxWait>

<minIdle>5</minIdle>

</dbConfig>

<dbConfig name="esbMountRegistry">

<url>jdbc:oracle:thin:wso2_greg@qcdvcn1001-vip.dev.rsft.net:15000:DEV541</url>

<userName>wso2_greg</userName>

<password>wso2_greg</password>

<driverName>oracle.jdbc.driver.OracleDriver</driverName>

<maxActive>50</maxActive>

<maxWait>60000</maxWait>

<minIdle>5</minIdle>

</dbConfig>

[1]http://wso2.org/library/tutorials/2010/11/setup-wso2-esb-cluster-wso2-greg

Monitor WSO2 Servers with Wireshark

2011-07-04T23:13:00.000-07:00

I recently had to look in to how to use Wireshark to monitor the traffic between set of WSO2 products, I found some useful configuration steps which was bit difficult to find in a single place in internet. We had a requirement of monitoring all the HTTP traffic and we wanted to monitor complete payload even though some of the transactions were HTTPS, so I will be describing how to configure Wireshark for a scenario like this. Since I was new to Wireshark I found the initial instructions were not very clear to start using Wireshark, so that is one of another motivation for writing this blog post. This blog post will be a very quick one which doesn't contains any screenshots, I hope to write a detail one but I need to write this before I forget these steps...

My Environment is Ubuntu so when you install it using Ubuntu Software Center you will get a package which is compiled with GnuTLS so to monitor HTTPS traffic you don't have to compile Wireshark again. If you are on Non-Unix system you have to compile it with GnuTLS (there are plenty of documentation on how to do this).

I assume you have a service running on WSO2 WSAS which is secured and you have a client to invoke that Service, and you have another client invoke another unsecured Service in WSAS, with this setup you can monitor HTTP and HTTPS traffic goes to both services.

Start Wireshark and see whether you see set of Interfaces where you can monitor, if you do not see any interface, it's because you do not have enough rights to monitor any of the interfaces. So please start as a root/sudo mode if you did not see any interface.
Now go to Edit -> Preferences -> Protocols -> HTTP there you will see two entries like "TCP/Ports" and "SSL/Ports". Add your Servers (WSO2 WSAS) HTTP port in to TCP/Ports list with a comma if you have number of ports to configure in a scenario where you want to monitor traffic among few hops add them as comma separated values. (Ex: HTTP - 9763).
Now add your server HTTPS port in to SSL/Ports entry, by default it's having 443 to monitor browser HTTPS traffic (Ex:, HTTPS - 9443).
Now you are in a position to monitor the traffic goes to WSAS by applying http filter. But you will not see the encrypted messages going to the Secured Service. To decrypt the messages which goes to WSAS you need to export the private key of the server (WSO2 WSAS). To do that you can use a simple tool like Keytool IUI[2].
Download the keytool IUI [2], extract it and run the script (I got some errors in the tool when I was trying to run the shell script, so if you get the same just run the following command). $JAVA_HOME/bin/java -Xms128m -Xmx196m -jar rc15ktl.jar
This will open the Keytool and go to Export -> KeyStores Entry -> Private Key There you will see four fields to be filled. Now what we are going to do is simply get the private key of the WSO2 WSAS in unencrypted format and add that in to Wireshark which will help to decrypt the messages.
Give the keystore file path which is WSAS_HOME/resources/security/wso2carbon.jks, and the password will be wso2carbon, The add private Key and Certificate Chain file locations to the place where you want to store the private key. And make sure you put the file type as PEM in last two fields.
After pressing OK you will ask to select the select Keypair trust among a list, select the entry you have "wso2carbon" as the alias. Lets assume the output private key file path is /home/lahiru/client/fhlb/wso2is-3.0.1/resources/security/private.pem.
Now you have have the private key of the server in unencrypted format, now go to Edit -> Preferences -> Protocols -> SSL there you will see a field (empty) RSA Key list for that add the following entry. 127.0.0.1,9443,http,/home/lahiru/client/fhlb/wso2is-3.0.1/resources/security/private.pem ,,,private-key-path-of-the-server
Since we are going to monitor traffic in the same machine we are selecting the interface 127.0.0.1 (If your operation system is Windows things will not work out of the box with loop-back address so for window users please refer this[1]). To select the interface go to Capture -> Interfaces there you will see 127.0.0.1 press the start button in 127.0.0.1 interface.
Now you can send two messages to secure and un-secure services then after you get the responses go to Wireshark and add Filter (from the top field with the name filters) http.
Now ideally you should see four entries, request-response messages for two transactions and you will be able to view the content of the secure request-response messages too.

Please refer[3] for further detail about how to decrypt the messages using Wireshark.

[1]http://wiki.wireshark.org/CaptureSetup/Loopback

[2]http://www.softpedia.com/get/Security/Security-Related/KeyTool-IUI.shtml

[3]http://htluo.blogspot.com/2009/01/decrypt-https-traffic-with-wireshark.html

Mobile Cloud Computing: 5 Key Trends: Page 3

2011-07-02T04:42:00.000-07:00

“So much emphasis is being placed on managing cloud services that it seems to me that enterprises are forgetting one key piece of the IT mix – devices,” David Link of ScienceLogic said. “It’s not just services that they need to worry about anymore from a management perspective.
Looking at the various reports coming out of IBM, Ericsson and Cisco, we could be looking at potentially one trillion Internet connected devices by 2015. To put that in perspective, we passed the five-billion milestone in late August/early September.”
IBM predicts that there will be 1 trillion connected devices by 2015. Cisco moves that up to 2013.
Ericsson looks further ahead and believes there will be 50 billion connected devices by 2020, and IMS Research notes that we only just passed the 5-billion-device threshold in August 2010.
“If you can put a sensor and a network anywhere, then think of all of the places you might want to monitor and all of the data you’d like to collect,” said Joy Weiss, President and CEO of Dust Networks. “Today, with sensors running on batteries or harvested energy, you already have the ability to get information from anywhere or connect to anything – anywhere.”
Dust Networks provides wireless sensor networking (WSN) technology that can serve as the cornerstone for such things as industrial sensor networks, smart power grids and smart buildings. Tiny sensors, or “motes,” can be embedded into or attached to various devices. They then communicate over low-power 802.15.4 and form “SmartMeshes,” which communicate information back to a single device that manages the sensor network and connects to enterprise applications or transmits data over the public Internet.
When I mentioned that I’ve heard this trillion-connected device story before, over and over again, for years and years, Weiss admitted that she’s been telling that story for years herself.
What’s different this time is that immediate value is driving the technology, rather than technology providers up to their ears in science projects and hunting around for interesting use cases.
“What we see in early applications, although there is a broad variety, is that the application drives the deployment. It’s not like someone is coming into the enterprise and dropping sensors around randomly and expecting them to automatically communicate with the rest of your systems and networks,” Weiss said.
For instance, many utilities are already deploying wireless mesh infrastructure to enable smart grids. Energy savings, predictive maintenance and asset management are driving the deployment of sensors and the creation of these networks, and they’re already paying big dividends.

5. It’s happening whether you’re ready for it or not.

Sensors are already monitoring environmental conditions in vineyards. Smart parking meters are already sending text messages to alert drivers of vacant parking spaces, and sensors are being used to monitor corrosion in pipelines. Previously, these kinds of applications had limited scalability because they tied back into proprietary applications and systems. Soon, though, it will be the mobile cloud driving the so-called “smarter planet,” as IBM likes to call it.The “Internet of Things” or this "Device-aggeddon" as David Link of ScienceLogic refers to it is already here. It’s happening, and the only reason that we don’t realize it is that much of this is happening in the background.
Sound familiar? That’s exactly what happened in the early stages of cloud adoption. I can’t tell you how many emails I received from CIOs and IT managers telling me that they would never sign off on moving core applications to the cloud, yet they were already using Salesforce.com, OpenAir or some other SaaS application. They just didn’t think of those as cloud-based applications.
Similarly, it’s hard to tell whether your power grid is smart or not. How would you know if a pipeline is connected to the public Internet?
You won’t until your organization gets into the game and you have to start factoring a broad variety of devices and networks into your larger IT plans.

Mobile Cloud Computing: 5 Key Trends: Page 2

2011-07-02T04:41:00.000-07:00

(Page 2 of 3)

Crampton believes that the best approach is to start figuring out how to control data and how to manage access to that data, rather than simply blocking classes or types of device. “If you create different categories of data, you can then define what each level means and how to control it,” he said.
For instance, Level 1 data wouldn’t have much risk associated with it and you wouldn’t lock it down as tightly as, say, Level 3 data, which could be sensitive, proprietary data that may not be available on mobile devices or even beyond the physical walls of the organization.
“You also need visibility into who is coming into your environment,” Crampton said. “An acceptable level of risk, then, could mean that you don’t care if the information goes out of the network, so long as you know who is getting it.”
Organizations will then need to create even more data-use policies for more scenarios. If they do, many mobile risks become much more manageable.
The mobile cloud could again be a boon here. If applications have mobile-app components house in the mobile cloud, it’s easy to shuffle mobile users into a safer, more controlled environment.

3. The Mobile Cloud will change how we work.

Microsoft, Google, Salesforce.com, and plenty of others are rolling out cloud-based features that enable collaboration. Much enterprise collaboration, though, is still done through a tried-and-trued communications medium: email.And what’s the first application everyone wants on their smartphone? That’s right: email.
Email is also often the first application companies seek to move to the cloud. A recent Frost & Sullivan report sums it up nicely:
"After years of uncertainty, the North American hosted enterprise email markets have finally taken off. As businesses perceive email as mission-critical, they were skeptical about email applications residing outside the enterprise in a third-party data center in the past.
However, the entry of large cloud-based providers and on-premise email vendors has lent credibility to the software as a service (SaaS) delivery model. In addition, technology maturity and cost advantages have helped spur the growth of hosted email services among enterprise users."
According to the report, the size, complexity and storage requirement of email are driving it to third-party providers in the cloud. Compliance issues and demand for mobile access are only going to accelerate that trend. “The basic tenet of the cloud services model is that customers have a greater choice in terms of the number and range of applications,” Frost & Sullivan argues.
The mobile cloud will change how we work in more ways than simply how we access email and how IT manages it. Today, location-awareness is pretty much inherent in mobility. Location-awareness will change how sales teams prospect, how IT delivers security, how marketing and advertising firms interact with customers.
Applications will be more fractured (the single-purpose app model), yet they may well integrate more easily with related apps.
“Mobile devices are going to create some challenges for IT, but they’re going to create a different working ‘sensation’ for individuals,” Crampton said. “When you can do things like connect your social network to your car, all sorts of behaviors will change. There will be a different paradigm for how we use and think of mobility.”

4. The Mobile Cloud will pave the way for the “Internet of Things.”

Imagine a time when everything from refrigerators to parking meters to pacemakers is connected to the Internet?If you’re imagining a time well into the future, you’re either a cynic who’s grown wary of these promises and predictions (I’ll raise my hand as being guilty here), or you haven’t realized how cheap processing has become and how much downward price pressure there is on wireless networking.