androidservicejava

㈠ java与安卓是什么关系

Java，是由Sun
Microsystems公司于1995年5月推出的Java程序设计语言和Java平台的总称。用Java实现的HotJava浏览器（支持Java
applet）显示了Java的魅力：跨平台、动态的Web、Internet计算。从此，Java被广泛接受并推动了Web的迅速发展，常用的浏览器现在均支持Java
applet。 android以Java为编程语言，使接口到功能，都有层出不穷的变化，其中Activity等同于J2ME的MIDlet，一个
Activity
类（class）负责创建视窗（window），一个活动中的Activity就是在
foreground（前景）模式，背景运行的程序叫做Service。两者之间通过由ServiceConnection和AIDL连结，达到复数程序同时运行的效果。如果运行中的
Activity
全部画面被其他
Activity
取代时，该
Activity
便被停止（stopped），甚至被系统清除（kill）。
View等同于J2ME的Displayable，程序人员可以通过
View
类与“XML
layout”档将UI放置在视窗上，Android
1.5的版本可以利用
View
打造出所谓的
Widgets，其实Widget只是View的一种，所以可以使用xml来设计layout，HTC的Android
Hero手机即含有大量的widget。至于ViewGroup
是各种layout
的基础抽象类（abstract
class），ViewGroup之内还可以有ViewGroup。View的构造函数不需要再Activity中调用，但是Displayable的是必须的，在Activity
中，要通过findViewById()来从XML
中取得View，Android的View类的显示很大程度上是从XML中读取的。View
与事件（event）息息相关，两者之间通过Listener
结合在一起，每一个View都可以注册一个event
listener，例如：当View要处理用户触碰（touch）的事件时，就要向Android框架注册View.OnClickListener。另外还有Image等同于J2ME的BitMap。

㈡ android程序设计基础中service的基本原理是什么

1. 说明
android的后台运行在很多service，它们在系统启动时被SystemServer开启，支持系统的正常工作，比如MountService监听是否有SD卡安装及移除，ClipboardService提供剪切板功能，PackageManagerService提供软件包的安装移除及查看等等，应用程序可以通过系统提供的Manager接口来访问这些Service提供的数据，以下将说明他们的工具流程
2. 举例说明基本流程
以android系统支持sensor（传感器）实例来说明框架层的service和manager是如何配合工作的
1) 什么是sensor
sensor是传感器, 比如控制横竖屏切换利用的就是重力传感器(gsensor), 还有accelerator sensor可取得x, y, z三个轴上的加速度(应用如平衡球, 小猴吃香蕉等)
2) 应用程序调用（以下为关键代码）
sensorManager=(SensorManager)getSystemService(context.SENSOR_SERVICE);
lightSensor = sensorManager.getDefaultSensor(Sensor.TYPE_LIGHT);
sensorManager.registerListener(sensorListener, lightSensor, SensorManager.SENSOR_DELAY_NORMAL);
3) Manager层
a) 提供给应用程序调用的接口，同实与Service交互，实现功能
frameworks/base/core/java/android/hardware/SensorManager.java
4) Service层
a) 开机时就运行的管理Sensor的后台服务
frameworks/base/services/java/com/android/server/SensorService.java
b) snesor后台服务需要的JNI，通过它与系统级交互
frameworks/base/services/jni/com_android_server_SensorService.cpp
5) 系统层
a) 传感器的头文件，硬件提供商按此文件的定义实现其功能
hardware/libhardware/include/hardware/sensors.h
b) 传感器的系统层实现，与内核交互，此处通常是硬件提供商提供的
hareware/libsensors
6) 内核及硬件层
内核访问硬件，同时以设备文件等方式提供给上层控制接口和传感器数据
3. 系统层实现
1) frameworks/base/core/java/android/*Manager.java 对应用的接口
2) frameworks/base/core/jni/ 对应用的接口的JNI
3) frameworks/base/services/java/com/android/server/ 后台服务
4) frameworks/base/services/jni/ JNI与系统层接口
5) hardware/libhardware/include/ 系统层头文件
6) hardware/libxxx 系统库支持
7) 内核支持
4. 应用程序如何使用
1) 查看系统提供哪些服务
find frameworks/base/core/java/android/ -name *Manager.java
此处可以看到调用系统提供服务的入口
2) 一般register listener，事件发生时都收到回调
5. 新建一个service（以froyo为例）
1) 接口：接口供应用调用
frameworks/base/core/java/android/app/ContextImpl.java 加服务名与Manager对应
frameworks/base/core/java/android/content/Context.java 加服务名定义
2) Manager：提供服务对应的调用接口
frameworks/base/core/java/android/app/StartXXXXManager.java 实现调用接口
frameworks/base/core/java/android/app/IXXXXManager.aidl 定义调用接口
frameworks/base/Android.mk 加入aidl的编译
3) service：提供后台服务支持
frameworks/base/services/java/com/android/server/XXXXService.java 服务实现
frameworks/base/services/java/com/android/server/SystemServer.java 启动服务

㈢ 怎样在android的service中调用Activity中的getWindow函数

GetWindow 函数功能：该函数返回与指定窗口有特定关系（如Z序或所有者）的窗口句柄。 函数原型：HWND GetWindow（HWND hWnd，UNIT nCmd）； 参数： hWnd:窗口句柄。要获得的窗口句柄是依据nCmd参数值相对于这个窗口的句柄。 nCmd:说明指定窗口与要获得句柄的窗口之间的关系。该参数值可以是下列之一： GW_CHILD：如果指定窗口是父窗口，则获得的是在Z序顶端的子窗口的句柄，否则为NULL。函数仅检查指定父窗口的子窗口，不检查继承窗口。 GW_ENABLEDPOUP：（WindowsNT 5.0）返回的句柄标识了属于指定窗口的处于使能状态弹出式窗口（检索使用第一个由GW_HWNDNEXT 查找到的满足前述条件的窗口）；如果无使能窗口，则获得的句柄与指定窗口相同。 GW_HWNDFIRST：返回的句柄标识了在Z序最高端的相同类型的窗口。如果指定窗口是最高端窗口，则该句柄标识了在Z序最高端的最高端窗口；如果指定窗口是顶层窗口，则该句柄标识了在z序最高端的顶层窗口：如果指定窗口是子窗口，则句柄标识了在Z序最高端的同属窗口。 GW_HWNDLAST:返回的句柄标识了在z序最低端的相同类型的窗口。如果指定窗口是最高端窗口，则该柄标识了在z序最低端的最高端窗口：如果指定窗口是顶层窗口，则该句柄标识了在z序最低端的顶层窗口；如果指定窗口是子窗口，则句柄标识了在Z序最低端的同属窗口。 GW_HWNDNEXT：返回的句柄标识了在Z序中指定窗口下的相同类型的窗口。如果指定窗口是最高端窗口，则该句柄标识了在指定窗口下的最高端窗口：如果指定窗口是顶层窗口，则该句柄标识了在指定窗口下的顶层窗口；如果指定窗口是子窗口，则句柄标识了在指定窗口下的同属窗口。 GW HWNDPREV：返回的句柄标识了在Z序中指定窗口上的相同类型的窗口。如果指定窗口是最高端窗口，则该句柄标识了在指定窗口上的最高端窗口；如果指定窗口是顶层窗口，则该句柄标识了在指定窗口上的顶层窗口；如果指定窗口是子窗口，则句柄标识了在指定窗口上的同属窗口。 GW_OWNER：返回的句柄标识了指定窗口的所有者窗口（如果存在）。 返回值：如果函数成功，返回值为窗口句柄；如果与指定窗口有特定关系的窗口不存在，则返回值为NULL。 若想获得更多错误信息，请调用GetLastError函数。 备注：在循环体中调用函数EnumChildWindow比调用GetWindow函数可靠。调用GetWindow函数实现该任务的应用程序可能会陷入死循环或退回一个已被销毁的窗口句柄。 速查：Windows NT：3.1以上版本；Windows：95以上版本；Windows CE：1.0以上版本；头文件：winuser.h；库文件：user32.lib。

㈣ android和java webservice RSA处理的不同

android和java webservice RSA处理的不同如下：
1.最近做RSA加密用于增强android客户机与服务器(JavaEE)数据传输的安全性。发现在andorid机器上生成的（密钥对由服务器在windows xp下生成并将公钥发给客户端保存）密码无法在服务器通过私钥解密。
2.为了测试，在服务器本地加解密正常，另外，在android上加解密也正常，但是在服务器中加密（使用相同公钥）后的密码同样无法在android系统解密（使用相同私钥）。
3.由于对RSA加密算法不了解，而且对Java RSA的加密过程也不清楚、谷歌一番，才了解到可能是加密过程中的填充字符长度不同，这跟加解密时指定的RSA算法有关系。
4.比如，在A机中使用标准RSA通过公钥加密，然后在B系统中使用“RSA/ECB/NoPadding”使用私钥解密，结果可以解密，但是你会发现解密后的原文前面带有很多特殊字符，这就是在加密前填充的空字符；如果在B系统中仍然使用标准的RSA算法解密，这在相同类型的JDK虚拟机环境下当然是完全一样的，关键是android系统使用的虚拟机（dalvik）跟SUN标准JDK是有所区别的，其中他们默认的RSA实现就不同。
5.更形象一点，在加密的时候加密的原文“abc”，你直接使用“abc”.getBytes()方法获得的bytes长度可能只有3，但是系统却先把它放到一个512位的byte数组里，new byte[512]，再进行加密。但是解密的时候你使用的是“加密后的密码”.getBytes()来解密，解密后的原文自然就是512长度的数据，即是在“abc”之外另外填充了500多字节的其他空字符。

㈤ 关于在Android框架中增加service

照葫芦画瓢呗，你看看framework/base/services/java/com/android/server/下的例子。一般一个server由xxxxService.java xxxxManager.java IxxxxManager.aidl组成。Manager和aidl在frameworks/base/core/java/android/。如果是要系统启动时就运行，则需要在SystemServer.java中加上启动你的Service的代码。

㈥ 如何在Android源码中加入Java层系统服务

1. 在android/app/目录下创建接口文件IServiceTest.aidl
package android.app;
oneway interface IServiceTest
{
void show();
}
2. 在Android.mk文件中的变量LOCAL_SRC_FILES中加入core/java/android/app/IServiceTest.aidl
如果要在sdk中发布这个服务就在变量aidl_files中加入一样的路径。
3. 通过aidl编译器编译IServiceTest.aidl，会生成一个IServiceTest.java文件。
4. 创建服务类ServiceTestSerice
class ServiceTestSerice extends IServiceTest.Stub{
private static final String TAG = “ServiceTestSerice”;
Context mContext;
public ServiceTestSerice(Context context){
mContext = context;
}
public void show() throws RemoteException {
System.out.println(“My ServiceTestSerice”);
}
}
.5. 注册服务
Java系统服务在ServerThread类的run()方法中生成并注册到android平台，生成ServiceTestSerice实例对象，通过ServiceManager的addService方法将服务注册到系统中。
try{
serviceTestSerice = new ServiceTestSerice(context);
ServiceManager.addService(Context.SERVICE_TEST, serviceTestSerice);
} catch (Throwable t) {

}

ServiceTestSerice serviceTestSerice；
以上代码在ServerThread类的run()方法中。
在Context类中加入：
public static final StringSERVICE_TEST = “servicetest”
ServiceTestManager sServiceTestManager;
6. 使用系统服务
编写一个ServiceTestManager类，为包装类。
public class ServiceTestManager{
private final IServiceTest mService;

ServiceTestManager(IServiceTest service){
mService = service;
}

public void test(){
try{
mService. show()
} catch (RemoteException ex){

}
}
}
7 提供应用层开发接口
在ContextImpl类中的getSystemService()方法中加入如下代码：
else if (SERVICE_TEST.equals(name)){
return getServiceTestManager();
}
private ServiceTestManager getServiceTestManager(){
synchronized(sSync) {
if (sServiceTestManager == null){
IBinder b = ServiceManager.getService(SERVICE_TEST);
IServiceTest service = IServiceTest.Stub.asInterface(b);
sServiceTestManager = new ServiceTestManager(service);
}
}
调用过程如下：
ServiceTestManager manager= (ServiceTestManager) getSystemService(Context. SERVICE_TEST);
manager.show();
8. 测试
make
make update-api 更新current.xml文件
生成system.imz文件，放到<ANDROID_SDK>/platform/android-20/images/目录下，
adb shell
service list

㈦ android 怎么利用service

1、要使用Service，首先就是在配置文件里吗添加Service，如果不填加，你的Service是不能够使用的。目前学到的方法有两种
方法一：<service android:enabled="true" android:name=".PlayService" />
方法二：<service android:name=".PlayService" />
点后面是Service类的名字。
2、工程包括两个类：
ServiceActivity.java
PlayService.java
其中：ServiceActivity.java定义了两个按钮，分别控制音乐的播放与停止。
用startService和stopService完成Activity与Service之间的切换，启动Service以及取消Service

㈧ 如何在Android中添加系统服务

在android中添加系统服务，下面以SurfaceComposer这个service为例，
① 首先提供接口文件ISurfaceComposer.h
//frameworks\native\include\gui\ISurfaceComposer.h
//首先是接口，c++实现是虚函数
class ISurfaceComposer: public IInterface {
public:
DECLARE_META_INTERFACE(SurfaceComposer);
// flags for setTransactionState()
enum {
eSynchronous = 0x01,
eAnimation = 0x02,
};
enum {
eDisplayIdMain = 0,
};
/* create connection with surface flinger, requires
* ACCESS_SURFACE_FLINGER permission
*/
virtual sp<ISurfaceComposerClient> createConnection() = 0;
}
② 建立BnSurfaceComposer
建立BnSurfaceComposer，需要重写BBinder的onTransact函数。
class BnSurfaceComposer: public BnInterface<ISurfaceComposer> {
public:
enum {
// Note: BOOT_FINISHED must remain this value, it is called from
// Java by ActivityManagerService.
BOOT_FINISHED = IBinder::FIRST_CALL_TRANSACTION,
CREATE_CONNECTION,
CREATE_GRAPHIC_BUFFER_ALLOC,
CREATE_DISPLAY_EVENT_CONNECTION,
CREATE_DISPLAY,
DESTROY_DISPLAY,
GET_BUILT_IN_DISPLAY,
SET_TRANSACTION_STATE,
AUTHENTICATE_SURFACE,
BLANK,
UNBLANK,
GET_DISPLAY_INFO,
CONNECT_DISPLAY,
CAPTURE_SCREEN,
};
virtual status_t onTransact(uint32_t code, const Parcel& data,
Parcel* reply, uint32_t flags = 0);
};
③ Bpxxx的实现
frameworks\native\libs\gui\ISurfaceComposer.cpp中，
//Bp实现，代理端
class BpSurfaceComposer : public BpInterface<ISurfaceComposer>
{
public:
BpSurfaceComposer(const sp<IBinder>& impl)
: BpInterface<ISurfaceComposer>(impl)
{
}
//代理接口
virtual sp<ISurfaceComposerClient> createConnection()
{
uint32_t n;
Parcel data, reply;
data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
remote()->transact(BnSurfaceComposer::CREATE_CONNECTION, data, &reply);
return interface_cast<ISurfaceComposerClient>(reply.readStrongBinder());
}
}
④ Bnxxx的实现
//Bn端，即server端
status_t BnSurfaceComposer::onTransact(
uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
{
switch(code) {
case CREATE_CONNECTION: {
CHECK_INTERFACE(ISurfaceComposer, data, reply);
//createConnection就是server端的实现函数
sp<IBinder> b = createConnection()->asBinder();
reply->writeStrongBinder(b);
return NO_ERROR;
}
default: {
return BBinder::onTransact(code, data, reply, flags);
}
}
// should be unreachable
return NO_ERROR;
}
⑤ 注册service
通过上面几步已经完成了service的建立，我们需要将service注册到service manager中。
class SurfaceFlinger : public BnSurfaceComposer,
//在frameworks\native\services\surfaceflinger\main_surfaceflinger.cpp中，
// publish surface flinger
sp<IServiceManager> sm(defaultServiceManager());
sm->addService(String16(SurfaceFlinger::getServiceName()), flinger, false);
⑥ 使用service
//首先获取代理端BpSurfaceComposer
sp<ISurfaceComposer> composer(ComposerService::getComposerService());
//直接调用代理BpSurfaceComposer的接口
sp<IGraphicBufferAlloc> alloc(composer->createGraphicBufferAlloc());
其中getComposerService()的实现为，
/*static*/ sp<ISurfaceComposer> ComposerService::getComposerService() {
ComposerService& instance = ComposerService::getInstance();
Mutex::Autolock _l(instance.mLock);
if (instance.mComposerService == NULL) {
ComposerService::getInstance().connectLocked();
assert(instance.mComposerService != NULL);
ALOGD("ComposerService reconnected");
}
return instance.mComposerService;
}
void ComposerService::connectLocked() {
const String16 name("SurfaceFlinger");
//获取service，返回的mComposerService是BpSurfaceComposer，有了Bp就能直接调用代理接口了
while (getService(name, &mComposerService) != NO_ERROR) {
usleep(250000);
}
assert(mComposerService != NULL);
// Create the death listener.
class DeathObserver : public IBinder::DeathRecipient {
ComposerService& mComposerService;
virtual void binderDied(const wp<IBinder>& who) {
ALOGW("ComposerService remote (surfaceflinger) died [%p]",
who.unsafe_get());
mComposerService.composerServiceDied();
}
public:
DeathObserver(ComposerService& mgr) : mComposerService(mgr) { }
};
mDeathObserver = new DeathObserver(*const_cast<ComposerService*>(this));
mComposerService->asBinder()->linkToDeath(mDeathObserver);
}
java添加service
Android为了方便开发人员，提供了AIDL工具，简化了编写service的难度。下面以添加TestService这个服务为例，
① 编写AIDL文件
package android.app;
interface ITestService {
boolean enableWifi(boolean enabled);
}
TestService的AIDL文件提供了一个接口，enableWifi()。
② 创建TestService服务
TestService 服务需要继承ITestService.Stub类，这个类就是通过AIDL工具对①中的AIDL文件处理后产生的，
class TestService extends ITestService.Stub {
//实现接口
public boolean enableWifi(boolean enabled)
{
......
}
}
③ Context.java中添加service名字字符串
// Context.java中添加service名字字符串
public static final String TEST_SERVICE = "my_test";
④ 向ServiceManager中注册service
java中大部分的系统service都是在SystemServer中去向service manager注册的，
//ServiceManager注册service
// 在SystemServer.java中，模仿其他向ServiceManager添加service的方法
try {
TestService myService = new TestService(context);
ServiceManager.addService(Context.TEST_SERVICE, myService);
} catch (Throwable e) {
reportWtf("register my test service fail", e);
}
⑤创建服务对应的Manager
对于每一个service而言，通常会有一个相关的Manager。 Managers提供API给app使用，成为SDK的一部分，是apps和remote service的中间桥梁。Manager中的接口和Service中的接口必须一一对应。
public class TestServiceManager{
private final ITestService mService;
private final Context mContext;
//构造函数中传入的service，其实就是BpTestService
TestServiceManager(Context context,ITestService service) {
mContext = context;
mService = service;
}
public boolean enableWifi(boolean enabled) {
try {
return mService.enableWifi(enabled);
} catch (RemoteException ex) {
}
return false;
}
}
到目前为止，我们只是完成了Service的注册，但是还没有使用，该如何使用？
⑥ contextImpl中注册Manager
一旦我们实现了service和对应的Manager，需要有一种方法在app中调用他们。前面说过，Manager会成为SDK的一部分，供我们调用，那么Manager和Service是如何联系起来的？首先需要将我们的service和mangager注册到execution context，即contextImpl中，
registerService(TEST_SERVICE, new ServiceFetcher() {
public Object createService(ContextImpl ctx) {
IBinder b = ServiceManager.getService(TEST_SERVICE);
//asInterface(BpBinder)后就是BpTestService
ITestService service = ITestService.Stub.asInterface(b);
//创建TestServiceManager，第二个参数为BpBpTestService
return new TestServiceManager(ctx.getOuterContext(), service);
}});
registerService的第二个参数是一个ServiceFetcher对象，这里直接在调用时，新建了一个ServiceFetcher类，重写了createService方法。
ContextImpl.java中的registerService()方法，其核心就是把servicename和ServiceFetcher对象放到一个Hash的键值对中。
private static void registerService(String serviceName, ServiceFetcher fetcher) {
if (!(fetcher instanceof StaticServiceFetcher)) {
fetcher.mContextCacheIndex = ++;
}
SYSTEM_SERVICE_MAP.put(serviceName, fetcher);
}
⑦ app如何使用service
那么app是如何调用的呢?
import android.app.TestServiceManager;
import android.content.Context;
TestServiceManager mTestServiceManager;
mTestServiceManager=(TestServiceManager)context.getSystemService(Context.TEST_SERVICE);
然后直接调用TestServiceManager中的方法即可，其中的奥秘需要分析下getSystemService函数。
ContextImpl.java中，
@Override
public Object getSystemService(String name) {
ServiceFetcher fetcher = SYSTEM_SERVICE_MAP.get(name);
//从ServiceFetcher 中获取service
return fetcher == null ? null : fetcher.getService(this);
}
getService()函数的核心就是上面重写的createService()函数，返回的就是TestServiceManager对象，所以通过context.getSystemService返回的是Manager对象。
public Object getService(ContextImpl ctx) {
ArrayList<Object> cache = ctx.mServiceCache;
Object service;
synchronized (cache) {
if (cache.size() == 0) {
// Initialize the cache vector on first access.
// At this point
// is the number of potential services that are
// cached per-Context.
for (int i = 0; i < ; i++) {
cache.add(null);
}
} else {
service = cache.get(mContextCacheIndex);
if (service != null) {
return service;
}
}
//调用重载的createService函数，返回的就是TestServiceManager对象
service = createService(ctx);
cache.set(mContextCacheIndex, service);
return service;
}
}

㈨ 用eclipse做Android开发，怎么新建一个service类new里面没有service

一、用 eclipse 创建一个 WebService 服务器端
1、 首先新建一个动态 web 工程，选择 File->New->Dynamic Web Project，命名为 axis。
2、 创建一个包， 再新建一个类，右击 src，选择 New->Class，命名为 AddService 添加方法 add： public class AddService { public int add(int a, int b) { return a+b; } }
3、右击 AddService.java 文件，选择 Web Services->Create Web Service。
4、点击 next，选择方法 add，点击 next->Start server->Finish。这时可以看到 WebContent 目 录下多了个 wsdl 文件夹，axis 插件自动为我们生成了 AddService.wsdl。
5、我们可以对 AddService 的方法进行测试。右击 AddService.wsdl，选择 Web Services->Test with Web Services Explorer。选择 add 就可以该方法进行测试。
6、将 AddService.java 复制到 WebContent 目录下，并改名为 AddService.jws。
7、启动 tomcat，在浏览器中输入 http://localhost:8080/axis/AddService.jws，应该会看到提示： There is a Web Service here，点击 Click to see the WSDL，看到一个 xml 文件就成功了。
8、将 workspace 下的 axis 工程里的 WebContent 复制到了 tomcat 的 webapps 目录下，并改 名为 axis，方便访问。 启动 tomcat 服务器，在浏览器中输入：
http://localhost:8080/axis/AddService.jwswsdl
至此，WebService 服务端成功发布。
二、用 eclipse 创建一个 WebService 客户端 1、 新建一个动态 Web 工程 addTest，再创建 WebService 客户端： File->New->Other..->Web Services->Web Service Client。 （必须有 Web 工程才能创建 Web Service Client)
2、在 Service definition 输入框中输入地址： http://服务器 ip 地址:8080/axis/services/AddServicewsdl，单击下一步，选择输出文件夹，点 击 Finish。可以看到 src 下生成了一个包 DefaultNameSpace，里面有五个 java 文件。 （注意 输入地址跟前面的不一样) AddService.java 定义了 Web 服务接口； AddServiceService.java 定义了用于获取 Web 服务接口的方法； AddServiceServiceLocator.java 接口 AddServiceService 的具体实现； AddServiceSoapBindingStub.java Web 服务客户端桩，通过该类与服务器交互。
3、新建一个测试类 TestAddService，为了方便，这个类和刚刚产生的五个类在一个包下。 内容如下：

package DefaultNamespace; public class TestAddService {
public static void main(String[] args) throws Exception{
try{
AddServiceService service = new AddServiceServiceLocator(); AddService add = service.getAddService(); System.out.println(add.add(1, 1)); }catch(Exception e){ e.printStackTrace(); } } }
4、右击 TestAddService.java，Run As->Java Application。便可以控制台看到输出结果。

㈩ 关于android的service 和广播的问题（java相关）

广播发送了，应该是没有返回值，传递的参数都在intent中。
service可以有回调函数。