Android Spy App – How Android Spy Apps Can Catch A Cheating Spouse

Android spy app is a mobile monitoring, tracking, and spying software application which is utilized to spy on Android cell phones using the Android OS, such as the Motrola Droid, Nexus One phones. 

The way Android spy apps work, is that a individual should download the Android spy app directly into the Android device. This can be accomplished via the cell phone’s internet browser. 

Immediately after the Android spy app is downloaded and set up, the Android app becomes undetectable and straight away starts to secretly records a range of information (call logs, SMS messages, GPS locations), and then anonymously uploads all the info to an world-wide-web account. All of this happens in the background, while the person is using their phone. 

The individual that installed the software, can now log into their account, and view all the activity recorded on the Android cell phonephone. 

The following is a list of the most typical capabilities found on Android spy apps

Listen To Calls - Using an Android spy app, you can secretly listen to calls made from the Android phone you are monitoring.
Remote Monitoring – Some Android spy apps also enable you to secretly listen in on the surroundings of the Android phone.
Stealth GPS Tracking – With Stealth GPS tracking, it is possible to secretly monitor the GPS coordinates of the person you are spying on. Areas are captured and uploaded in fifteen minute intervals, giving you a obvious image exactly where the Android user is. Locations are then shown using Google Maps.
View Photos – This Android spy app feature enables you to secretly view photos stored on the Android device.
Secretly Read Text Messages – All SMS messages which are received or sent from the Android cell are secretly recorded. Full contents of each message are recorded along with the time and date sent.
View Call History Logs – This Android spy app feature will enable you to secretly read all incoming/outgoing call details of the cellular cellphone. In addition to the call information, the name stored in the phone’s contact list / address book that is assocated to the number in the call logs will be shown. This will give you some insight into the name they are assigning that number.

What are the reasons why someone would want to use Android spy phone apps? Here are a some of the most well known reasons.

* Catch A Suspected Cheating Spouse: The most common reason why somebody purchases Android spy apps, is to spy on their spouse or partner. With Android Spy phone software, a concerned spouse can easily find out the truth and determine if their partner is indeed being faithful. The great thing about Android spy apps is it enables a suspicious spouse to not only track their cheating spouse, but also listen to their calls, surroundings, and read their text messages.  If their spouse is indeed having an affair, an Android spy app will uncover the truth.  It’s not “if” they will get caught, it’s “when” it will happen.  There is no way a cheating spouse can escape the powerful spy features found on an Android spy app.

Other features include….

* Monitor Children Cell Use: For parents who are concerned about their teen’s cellular use, or need a way to monitor their children, an Android spy app is a perfect choice. Maybe they are worried their teen is involved in a prohibited activity or they want to make sure that their teen is where they are supposed to be, with Android spy phone software, all of this is possible. 

* Worker Monitoring: Android spy apps could also be used to watch cell use on company provided telephones. In certain industries, more buyer communiction is occuring on cell telephones through texts. Without knowing what is being said and / or not being able to have a record of the communication might be in violation of compliance rules and  laws. Also, in the event of a potential suit, not having records of particular customer communication may put the company in peril. With this type of software installed on company provided cell phones, bosses can keep records of such activity. 

Final Thoughts

In summary, Android spy phone software is really a cell phone monitoring & tracking application that’s used for a range of reasons to observe a person using an Android cellphone. Even though not everyone will agree with some of the reasons for wanting to spy on an Android cell phone, it’s up to the individual who purchases the software program to choose the best use. 

It really doesn’t matter what your reason is, Android spy phone software do work, and is the only way to secretly spy on and monitor on a Android cellphone.

If you want more information, check out www.androidspy.com

Development and remote installation of Java service for the Android Devices

Written by:
Igor Darkov, Software Developer of Device Team, Apriorit Inc.

In this article I’ve described:

How to develop simple Java service for the Android Devices; How to communicate with a service from the other processes and a remote PC; How to install and start the service remotely from the PC. 1. Java Service Development for the Android Devices

Services are long running background processes provided by Android. They could be used for background tasks execution. Tasks can be different: background calculations, backup procedures, internet communications, etc. Services can be started on the system requests and they can communicate with other processes using the Android IPC channels technology. The Android system can control the service lifecycle depending on the client requests, memory and CPU usage. Note that the service has lower priority than any process which is visible for the user.

Let’s develop the simple example service. It will show scheduled and requested notifications to user. Service should be managed using the service request, communicated from the simple Android Activity and from the PC.

First we need to install and prepare environment:

Download and install latest Android SDK from the official web site (developer.android.com); Download and install Eclipse IDE (www.eclipse.org/downloads/); Also we’ll need to install Android Development Tools (ADT) plug-in for Eclipse.

After the environment is prepared we can create Eclipse Android project. It will include sources, resources, generated files and the Android manifest.

1.1 Service class development

First of all we need to implement service class. It should be inherited from the android.app.Service (developer.android.com/reference/android/app/Service.html) base class. Each service class must have the corresponding <service> declaration in its package’s manifest. Manifest declaration will be described later. Services, like the other application objects, run in the main thread of their hosting process. If you need to do some intensive work, you should do it in another thread.

In the service class we should implement abstract method onBind. Also we override some other methods:

onCreate(). It is called by the system when the service is created at the first time. Usually this method is used to initialize service resources. In our case the binder, task and timer objects are created. Also notification is send to the user and to the system log: public void onCreate() { super.onCreate(); Log.d(LOG_TAG, “Creating service”); showNotification(“Creating NotifyService”); binder = new NotifyServiceBinder(handler, notificator); task = new NotifyTask(handler, notificator); timer = new Timer(); } onStart(Intent intent, int startId). It is called by the system every time a client explicitly starts the service by calling startService(Intent), providing the arguments it requires and the unique integer token representing the start request. We can launch background threads, schedule tasks and perform other startup operations. public void onStart(Intent intent, int startId) { super.onStart(intent, startId); Log.d(LOG_TAG, “Starting service”); showNotification(“Starting NotifyService”); timer.scheduleAtFixedRate(task, Calendar.getInstance().getTime(), 30000); } onDestroy(). It is called by the system to notify a Service that it is no longer used and is being removed. Here we should perform all operations before service is stopped. In our case we will stop all scheduled timer tasks. public void onDestroy() { super.onDestroy(); Log.d(LOG_TAG, “Stopping service”); showNotification(“Stopping NotifyService”); timer.cancel(); } onBind(Intent intent). It will return the communication channel to the service. IBinder is the special base interface for a remotable object, the core part of a lightweight remote procedure call mechanism. This mechanism is designed for the high performance of in-process and cross-process calls. This interface describes the abstract protocol for interacting with a remotable object. The IBinder implementation will be described below. public IBinder onBind(Intent intent) { Log.d(LOG_TAG, “Binding service”); return binder; }

To send system log output we can use static methods of the android.util.Log class (developer.android.com/reference/android/util/Log.html). To browse system logs on PC you can use ADB utility command: adb logcat.

The notification feature is implemented in our service as the special runnable object. It could be used from the other threads and processes. The service class has method showNotification, which can display message to user using the Toast.makeText call. The runnable object also uses it:

public class NotificationRunnable implements Runnable { private String message = null; public void run() { if (null != message) { showNotification(message); } } public void setMessage(String message) { this.message = message; } }

Code will be executed in the service thread. To execute runnable method we can use the special object android.os.Handler. There are two main uses for the Handler: to schedule messages and runnables to be executed as some point in the future; and to place an action to be performed on a different thread than your own. Each Handler instance is associated with a single thread and that thread’s message queue. To show notification we should set message and call post() method of the Handler’s object.

1.2 IPC Service

Each application runs in its own process. Sometimes you need to pass objects between processes and call some service methods. These operations can be performed using IPC. On the Android platform, one process can not normally access the memory of another process. So they have to decompose their objects into primitives that can be understood by the operating system , and “marshall” the object across that boundary for developer.

The AIDL IPC mechanism is used in Android devices. It is interface-based, similar to COM or Corba, but is lighter . It uses a proxy class to pass values between the client and the implementation.

AIDL (Android Interface Definition Language) is an IDL language used to generate code that enables two processes on an Android-powered device to communicate using IPC. If you have the code in one process (for example, in Activity) that needs to call methods of the object in another process (for example, Service), you can use AIDL to generate code to marshall the parameters.

Service interface example showed below supports only one sendNotification call:

interface INotifyService { void sendNotification(String message); }

The IBinder interface for a remotable object is used by clients to perform IPC. Client can communicate with the service by calling Context’s bindService(). The IBinder implementation could be retrieved from the onBind method. The INotifyService interface implementation is based on the android.os.Binder class (developer.android.com/reference/android/os/Binder.html):

public class NotifyServiceBinder extends Binder implements INotifyService { private Handler handler = null; private NotificationRunnable notificator = null; public NotifyServiceBinder(Handler handler, NotificationRunnable notificator) { this.handler = handler; this.notificator = notificator; } public void sendNotification(String message) { if (null != notificator) { notificator.setMessage(message); handler.post(notificator); } } public IBinder asBinder() { return this; } }

As it was described above, the notifications could be send using the Handler object’s post() method call. The NotificaionRunnable object is passed as the method’s parameter.

On the client side we can request IBinder object and work with it as with the INotifyService interface.  To connect to the service the android.content.ServiceConnection interface implementation can be used. Two methods should be defined: onServiceConnected, onServiceDisconnected:

ServiceConnection conn = null; … conn = new ServiceConnection() { public void onServiceConnected(ComponentName name, IBinder service) { Log.d(“NotifyTest”, “onServiceConnected”); INotifyService s = (INotifyService) service; try { s.sendNotification(“Hello”); } catch (RemoteException ex) { Log.d(“NotifyTest”, “Cannot send notification”, ex); } } public void onServiceDisconnected(ComponentName name) { } };

The bindService method can be called from the client Activity context to connect to the service:

Context.bindService(new Intent(this, NotifyService.class), conn, Context.BIND_AUTO_CREATE);

The unbindService method can be called from the client Activity context to disconnect from the service:

Context.unbindService(conn); 1.3 Remote service control

Broadcasts are the way applications and system components can communicate. Also we can use broadcasts to control service from the PC. The messages are sent as Intents, and the system handles dispatching them, including starting receivers.

Intents can be broadcasted to BroadcastReceivers, allowing messaging between applications. By registering a BroadcastReceiver in application’s AndroidManifest.xml (using <receiver> tag) you can have your application’s receiver class started and called whenever someone sends you a broadcast. Activity Manager uses the IntentFilters, applications register to figure out which program should be used for a given broadcast.

Let’s develop the receiver that will start and stop notify service on request. The base class android.content.BroadcastReceiver should be used for these purposes (developer.android.com/reference/android/content/BroadcastReceiver.html):

public class ServiceBroadcastReceiver extends BroadcastReceiver { … private static String START_ACTION = “NotifyServiceStart”; private static String STOP_ACTION = “NotifyServiceStop”; … public void onReceive(Context context, Intent intent) { … String action = intent.getAction(); if (START_ACTION.equalsIgnoreCase(action)) { context.startService(new Intent(context, NotifyService.class)); } else if (STOP_ACTION.equalsIgnoreCase(action)) { context.stopService(new Intent(context, NotifyService.class)); } } }

To send broadcast from the client application we use the Context.sendBroadcast call. I will describe how to use receiver and send broadcasts from the PC in chapter 2.

1.4 Android Manifest

Every application must have an AndroidManifest.xml file in its root directory. The manifest contains essential information about the application to the Android system, the system must have this information before it can run any of the application’s code. The core components of an application (its activities, services, and broadcast receivers) are activated by intents. An intent is a bundle of information (an Intent object) describing a desired action — including the data to be acted upon, the category of component that should perform the action, and other pertinent instructions. Android locates an appropriate component to respond to the intent, starts the new instance of the component if one is needed, and passes it to the Intent object.

We should describe 2 components for our service:

NotifyService class is described in the <service> tag. It will not start on intent. So the intent filtering is not needed. ServiceBroadcastReceived class is described in the <receiver> tag. For the broadcast receiver the intent filter is used to select system events: <application android:icon=”@drawable/icon” android:label=”@string/app_name”> … <service android:enabled=”true” android:name=”.NotifyService” android:exported=”true”> </service> <receiver android:name=”ServiceBroadcastReceiver”> <intent-filter> <action android:name=”NotifyServiceStart”></action> <action android:name=”NotifyServiceStop”></action> </intent-filter> </receiver> … 2. Java service remote installation and start 2.1 Service installation

Services like the other applications for the Android platform can be installed from the special package with the .apk extension. Android package contains all required binary files and the manifest.

Before installing the service from the PC we should enable the USB Debugging option in the device Settings-Applications-Development menu and then connect device to PC via the USB.

On the PC side we will use the ADB utility which is available in the Android SDK tools directory. The ADB utility supports several optional command-line arguments that provide powerful features, such as copying files to and from the device. The shell command-line argument lets you connect to the phone itself and issue rudimentary shell commands.

We will use several commands:

Remote shell command execution: adb shell <command> <arguments> File send operation: adb push <local path> <remote path> Package installation operation: adb install <package>.apk

I’ll describe the package installation process in details. It consists of several steps which are performed by the ADB utility install command:

First of all the .apk package file should be copied to the device. The ADB utility connects to the device and has limited “shell” user privileges. So almost all file system directories are write-protected for it. The /data/local/tmp directory is used as the temporary storage for package files. To copy package to the device use the command: adb push NotifyService.apk /data/local/tmp Package installation. ADB utility uses special shell command to perform this operation. The “pm” (Package Manager?) utility is present on the Android devices. It supports several command line parameters which are described in the Appendix I. To install the package by yourself execute the remote shell command: adb shell pm install /data/local/tmp/NotifyService.apk Cleanup. After the package is installed, ADB removes the temporary file stored in /data/local/tmp folder using the “rm” utility: adb shell rm /data/local/tmp/NotifyService.apk. To uninstall package use the “pm” utility: adb shell pm uninstall <package> 2.2 Remote service control

To be able to start and stop the NotifyService from the PC we can use the “am” (Activity Manager?) utility which is present on the Android device. The command line parameters are described in the Appendix II. The “am” utility can send system broadcast intents. Our service has the broadcast receiver which will be launched by the system request.

To start NotifyService we can execute remote shell command:

adb shell am broadcast –a NotifyServiceStart

To stop the NotifyService we can execute remote shell command:

adb shell am broadcast –a NotifyServiceStop

Note, that the NotifyServiceStart and NotifyServiceStop intents were described in the manifest file inside the <receiver> … <intent-filter> tag. Other requests will not start the receiver.

Appendix I. PM Usage (from Android console) pm [list|path|install|uninstall] pm list packages [-f] pm list permission-groups pm list permissions [-g] [-f] [-d] [-u] [GROUP] pm path PACKAGE pm install [-l] [-r] PATH pm uninstall [-k] PACKAGE The list packages command prints all packages. Use the -f option to see their associated file. The list permission-groups command prints all known permission groups. The list permissions command prints all known permissions, optionally only those in GROUP. Use the -g option to organize by group. Use the -f option to print all information. Use the -s option for a short summary. Use the -d option to only list dangerous permissions. Use the -u option to list only the permissions users will see. The path command prints the path to the .apk of a package. The install command installs a package to the system. Use the -l option to install the package with FORWARD_LOCK. Use the -r option to reinstall an exisiting app, keeping its data. The uninstall command removes a package from the system. Use the -k option to keep the data and cache directories around after the package removal. Appendix II. AM Usage (from Android console) am [start|broadcast|instrument] am start -D INTENT am broadcast INTENT am instrument [-r] [-e <ARG_NAME> <ARG_VALUE>] [-p <PROF_FILE>] [-w] <COMPONENT> INTENT is described with: [-a <ACTION>] [-d <DATA_URI>] [-t <MIME_TYPE>] [-c <CATEGORY> [-c <CATEGORY>] …] [-e|--es <EXTRA_KEY> <EXTRA_STRING_VALUE> ...] [--ez <EXTRA_KEY> <EXTRA_BOOLEAN_VALUE> ...] [-e|--ei <EXTRA_KEY> <EXTRA_INT_VALUE> ...] [-n <COMPONENT>] [-f <FLAGS>] [<URI>] Resources used: Android Installation Guide.

http://developer.android.com/sdk/1.5_r2/installing.html

Android Developer reference.

http://developer.android.com/reference/classes.html

Jesse Burns. Developing Secure Mobile Applications for Android.

https://www.isecpartners.com/files/iSEC_Securing_Android_Apps.pdf

Designing a Remote Interface Using AIDL

http://developer.android.com/guide/developing/tools/aidl.html

First Android Build Shown to Mobile Phone Developers

This past week Google’s developer’s conference was one of the first demos of the Android mobile phone operating system.  Announced last year by the Open Handset Alliance, a group of mobile phone manufacturers and software houses who want to have one unilateral platform for all mobile phones to run on Android looks to be one of the most interesting revolutions in the Mobile phones market.

Being developed by Google the phones are highly likely to blend well with other Google-ware like the popular Maps service and Google Mail service.  The stand out feature is that the operating system is being designed to run on a wide range of mobile phones regardless of their feature set.  In a similar way to how PC operating systems are made to work on a wide range of computers with varying specifications Android will take advantage of specific phone features such as built in GPS and touch screen interfaces.

This past week had the operating system running on a touch screen unnamed handset and it was sporting a number of new features since it was last shown off earlier in the year.  One exciting feature was how the handset was unlocked; the user had to draw a specific shape on the touch screen to unlock the keypad.  Another feature took advantage of the GPS function by having an on screen compass which had been tried on other handsets such as the GPS enabled S60 phones offered by Nokia but attendees said the example shown by Google seemed to work much more fluidly than other attempts.

The decision to show off the software at their developers conference was obviously to entice the collective minds into coming up with some ideas for possible applications for their operating system, with it being open-source software, a factor popular with the programming masses, it looks promising that any mobile phones sporting Android’s operating system would have a lot to offer the stale mobile phones market.

Obviously a lot of comparisons were made between the software and Apple’s stand out mobile phone the iPhone, the interface seemed to bear some of the Apple hallmarks such as saving Youtube links as icons on the main screen and a touch based interface.

The Android operating system is currently nearing completion with handset manufacturers Motorola, HTC and Samsung all volunteering to use Android on their forth-coming mobile phones in the next year.

Android Looks Set to Exterminate the Mobile Phones Market

Many people have been waiting on baited breath for news from Google to make an official announcement about a rumoured “gPhone”, the internet search giant’s first attempt in the mobile phones industry.

This phone has been hotly tipped by industry insiders and internet geeks as the true opposition to Apple’s iPhone in the latest mobile phone war. Both companies have developed a perception of “hipness” in “techy” circles and seem likely to be direct competitors when getting the image-conscious buyer to buy the latest mobile gadget.

In early November this anticipation was dashed as Google, along with an alliance of mobile phone-related companies, declared its mobile phone project was not for a single handset. Rather, the company is planning to develop a platform, or operating system, that will allow greater functionality to all mobile phones. The formation of the Open Handset Alliance (OHA), which includes such industry heavyweights as Samsung, Motorola, T-Mobile and O2’s parent Telephonica, is gathering to support Google’s venture, called Android.

Android is set to be the next multi-platform mobile software operating on many different handsets. It promises to bring not only an operating system but also middleware and key applications. Many of Google’s most popular applications like GMail and Google Maps already have mobile versions phone users can run through Java. Android intends to make applications like this more functional on mobile phones but also to provide a fuller internet experience on the go.

While mobile phones are seeing speed increases, they still struggle with web pages when browsing the internet with HSDPA and GPRS and often users are stuck having to view cut-down WAP pages instead. With the gathered intelligence from Google and other partners, the belief is that that all mobile phones will have the capability for full web browsing.

Aside from the internet focus, developers will be provided an easier platform to develop their applications for Android. Aside from Google’s own applications, it will be much simpler for independent software developers to make programs that not only work on multiple phones but also collaborate with other applications.

When asked at its announcement whether Android will turn into an actual gPhone in the future, Google said this is not a gPhone per se, but that Android provides the ideal breeding ground for their own mobile phones.

But while consumers are speculating over one particular phone they fail to see the possibility that Android will effectively create thousands of “gPhones”. So until the announcement of a specific Google-branded handset, everyone will just have to wait and drool over the fake pictures posted on websites for the next year or two.

More About Android Smartphones

The cat is out of the bag. Lifestyle gadget enthusiasts are whispering to one another the prospects of Google Android – a new OS that looks to be a strong contender against Apple’s iPhone. For years, Apple has had very little competition. The iPhone appeared to have dominated the mobile community, and to date, it’s still the most popular mobile gadget around.

One of the main reasons why the iPhone is so popular is because Apple allows third party developers to develop applications for the iPhone. The applications are then distributed through Apple’s website. This is a highly strategic business move adopted by Apple, and one that has proven to work very well.

This concept is not new. Other non mobile platforms have adopted a similar concept, and have achieved great success as well. For example, both MySpace and Facebook, 2 immensely popular social community sites, have launched their own developer platform. Like the iPhone, developers can develop third party applications on these platforms.

The trend is rather obvious – user generated application based on an open concept is in. The iPhone’s success didn’t go unnoticed. Google is a strong player looking to compete in this sphere.

Recently, lots of buzz has been generated on Google Android – a brand new mobile OS. The key difference between Google Android and the iPhone OS is that the Android is an open OS. That means the OS can be used on any phone, not just the iPhone. By limiting the OS to the iPhone, Apple had isolated the rest of the phone manufacturers.

For years now, Apple had the upper hand. They can charge whatever price they wish to charge, and fans will still pay because they can’t get a similar system anywhere else. Google Android is looking to change all that. By leveling the playing field, consumers now have more choices. For sure, the prices for mobile gadgets (i.e. smartphones), will plummet once the Android gets adopted by other smartphone manufacturers. Already, major brand names like HTC, Motorola, Samsung, LG and Sony Ericsson are working closely with the Open Handset Alliance (the company now running Google Android) to realize this goal.

Being such a new technology, and with limited developers, enthusiasts will have to bear with a great number of useless mobile apps that will be released in the first few years. This is a common trend because developers are mostly experimenting with the system to see what works and what doesn’t.

As the OS matures, and more and more developers jump on the band wagon to release applications, there will be more and more useful applications. Consumers may then enjoy the full benefits of having an open mobile OS.

T-Mobile’s G1, based on Google Android, is already enjoying a fair amount of success. For sure, a G2 looks set to be launched in the near future. Lenovo is also looking for a piece of the pie with its very own Lenovo oPhone. Mobile enthusiasts have a lot to look forward to.