4c62fc0e1e
This is all of the basic pieces: - The WallpaperService now creates a surface with the window manager for its contents. - There is a simple service that displays a bitmap. - The wallpaper manager takes care of starting and stopping the service. - The window manager knows about wallpaper windows and how to layer them with the windows that want to be shown on top of wallpaper. Lots and lots of issues remain, but at this point you can actually write a wallpaper service, select it in the UI, and see it behind an activity.
540 lines
19 KiB
Java
540 lines
19 KiB
Java
/*
|
|
* Copyright (C) 2008 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.android.server;
|
|
|
|
import static android.os.FileObserver.*;
|
|
import static android.os.ParcelFileDescriptor.*;
|
|
|
|
import android.app.IWallpaperManager;
|
|
import android.app.IWallpaperManagerCallback;
|
|
import android.backup.BackupManager;
|
|
import android.content.ComponentName;
|
|
import android.content.Context;
|
|
import android.content.Intent;
|
|
import android.content.ServiceConnection;
|
|
import android.content.pm.PackageManager;
|
|
import android.content.pm.ResolveInfo;
|
|
import android.content.pm.ServiceInfo;
|
|
import android.content.pm.PackageManager.NameNotFoundException;
|
|
import android.content.res.Resources;
|
|
import android.os.Binder;
|
|
import android.os.IBinder;
|
|
import android.os.RemoteException;
|
|
import android.os.FileObserver;
|
|
import android.os.ParcelFileDescriptor;
|
|
import android.os.RemoteCallbackList;
|
|
import android.os.ServiceManager;
|
|
import android.service.wallpaper.IWallpaperConnection;
|
|
import android.service.wallpaper.IWallpaperEngine;
|
|
import android.service.wallpaper.IWallpaperService;
|
|
import android.service.wallpaper.WallpaperService;
|
|
import android.util.Log;
|
|
import android.util.Xml;
|
|
import android.view.IWindowManager;
|
|
import android.view.WindowManager;
|
|
|
|
import java.io.IOException;
|
|
import java.io.InputStream;
|
|
import java.io.File;
|
|
import java.io.FileNotFoundException;
|
|
import java.io.FileInputStream;
|
|
import java.io.FileOutputStream;
|
|
import java.util.List;
|
|
|
|
import org.xmlpull.v1.XmlPullParser;
|
|
import org.xmlpull.v1.XmlPullParserException;
|
|
import org.xmlpull.v1.XmlSerializer;
|
|
|
|
import com.android.internal.util.FastXmlSerializer;
|
|
|
|
class WallpaperManagerService extends IWallpaperManager.Stub {
|
|
static final String TAG = "WallpaperService";
|
|
static final boolean DEBUG = true;
|
|
|
|
Object mLock = new Object();
|
|
|
|
private static final File WALLPAPER_DIR = new File(
|
|
"/data/data/com.android.settings/files");
|
|
private static final String WALLPAPER = "wallpaper";
|
|
private static final File WALLPAPER_FILE = new File(WALLPAPER_DIR, WALLPAPER);
|
|
|
|
/**
|
|
* List of callbacks registered they should each be notified
|
|
* when the wallpaper is changed.
|
|
*/
|
|
private final RemoteCallbackList<IWallpaperManagerCallback> mCallbacks
|
|
= new RemoteCallbackList<IWallpaperManagerCallback>();
|
|
|
|
/**
|
|
* Observes the wallpaper for changes and notifies all IWallpaperServiceCallbacks
|
|
* that the wallpaper has changed. The CREATE is triggered when there is no
|
|
* wallpaper set and is created for the first time. The CLOSE_WRITE is triggered
|
|
* everytime the wallpaper is changed.
|
|
*/
|
|
private final FileObserver mWallpaperObserver = new FileObserver(
|
|
WALLPAPER_DIR.getAbsolutePath(), CREATE | CLOSE_WRITE | DELETE | DELETE_SELF) {
|
|
@Override
|
|
public void onEvent(int event, String path) {
|
|
if (path == null) {
|
|
return;
|
|
}
|
|
synchronized (mLock) {
|
|
// changing the wallpaper means we'll need to back up the new one
|
|
long origId = Binder.clearCallingIdentity();
|
|
BackupManager bm = new BackupManager(mContext);
|
|
bm.dataChanged();
|
|
Binder.restoreCallingIdentity(origId);
|
|
|
|
File changedFile = new File(WALLPAPER_DIR, path);
|
|
if (WALLPAPER_FILE.equals(changedFile)) {
|
|
notifyCallbacksLocked();
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
final Context mContext;
|
|
final IWindowManager mIWindowManager;
|
|
|
|
int mWidth = -1;
|
|
int mHeight = -1;
|
|
String mName = "";
|
|
ComponentName mWallpaperComponent;
|
|
WallpaperConnection mWallpaperConnection;
|
|
|
|
class WallpaperConnection extends IWallpaperConnection.Stub
|
|
implements ServiceConnection {
|
|
final Binder mToken = new Binder();
|
|
IWallpaperService mService;
|
|
IWallpaperEngine mEngine;
|
|
|
|
public void onServiceConnected(ComponentName name, IBinder service) {
|
|
synchronized (mLock) {
|
|
if (mWallpaperConnection == this) {
|
|
mService = IWallpaperService.Stub.asInterface(service);
|
|
attachServiceLocked(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void onServiceDisconnected(ComponentName name) {
|
|
synchronized (mLock) {
|
|
mService = null;
|
|
mEngine = null;
|
|
}
|
|
}
|
|
|
|
public void attachEngine(IWallpaperEngine engine) {
|
|
mEngine = engine;
|
|
}
|
|
|
|
public ParcelFileDescriptor setWallpaper(String name) {
|
|
synchronized (mLock) {
|
|
if (mWallpaperConnection == this) {
|
|
ParcelFileDescriptor pfd = updateWallpaperBitmapLocked(name);
|
|
if (pfd != null) {
|
|
saveSettingsLocked();
|
|
}
|
|
return pfd;
|
|
}
|
|
return null;
|
|
}
|
|
}
|
|
}
|
|
|
|
public WallpaperManagerService(Context context) {
|
|
if (DEBUG) Log.d(TAG, "WallpaperService startup");
|
|
mContext = context;
|
|
mIWindowManager = IWindowManager.Stub.asInterface(
|
|
ServiceManager.getService(Context.WINDOW_SERVICE));
|
|
WALLPAPER_DIR.mkdirs();
|
|
loadSettingsLocked();
|
|
mWallpaperObserver.startWatching();
|
|
}
|
|
|
|
@Override
|
|
protected void finalize() throws Throwable {
|
|
super.finalize();
|
|
mWallpaperObserver.stopWatching();
|
|
}
|
|
|
|
public void clearWallpaper() {
|
|
synchronized (mLock) {
|
|
File f = WALLPAPER_FILE;
|
|
if (f.exists()) {
|
|
f.delete();
|
|
}
|
|
}
|
|
}
|
|
|
|
public void setDimensionHints(int width, int height) throws RemoteException {
|
|
checkPermission(android.Manifest.permission.SET_WALLPAPER_HINTS);
|
|
|
|
if (width <= 0 || height <= 0) {
|
|
throw new IllegalArgumentException("width and height must be > 0");
|
|
}
|
|
|
|
synchronized (mLock) {
|
|
if (width != mWidth || height != mHeight) {
|
|
mWidth = width;
|
|
mHeight = height;
|
|
saveSettingsLocked();
|
|
}
|
|
}
|
|
}
|
|
|
|
public int getWidthHint() throws RemoteException {
|
|
synchronized (mLock) {
|
|
return mWidth;
|
|
}
|
|
}
|
|
|
|
public int getHeightHint() throws RemoteException {
|
|
synchronized (mLock) {
|
|
return mHeight;
|
|
}
|
|
}
|
|
|
|
public ParcelFileDescriptor getWallpaper(IWallpaperManagerCallback cb) {
|
|
synchronized (mLock) {
|
|
try {
|
|
mCallbacks.register(cb);
|
|
File f = WALLPAPER_FILE;
|
|
if (!f.exists()) {
|
|
return null;
|
|
}
|
|
return ParcelFileDescriptor.open(f, MODE_READ_ONLY);
|
|
} catch (FileNotFoundException e) {
|
|
/* Shouldn't happen as we check to see if the file exists */
|
|
Log.w(TAG, "Error getting wallpaper", e);
|
|
}
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public ParcelFileDescriptor setWallpaper(String name) {
|
|
checkPermission(android.Manifest.permission.SET_WALLPAPER);
|
|
synchronized (mLock) {
|
|
ParcelFileDescriptor pfd = updateWallpaperBitmapLocked(name);
|
|
if (pfd != null) {
|
|
clearWallpaperComponentLocked();
|
|
saveSettingsLocked();
|
|
}
|
|
return pfd;
|
|
}
|
|
}
|
|
|
|
ParcelFileDescriptor updateWallpaperBitmapLocked(String name) {
|
|
if (name == null) name = "";
|
|
try {
|
|
ParcelFileDescriptor fd = ParcelFileDescriptor.open(WALLPAPER_FILE,
|
|
MODE_CREATE|MODE_READ_WRITE);
|
|
mName = name;
|
|
return fd;
|
|
} catch (FileNotFoundException e) {
|
|
Log.w(TAG, "Error setting wallpaper", e);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public void setWallpaperComponent(ComponentName name) {
|
|
checkPermission(android.Manifest.permission.SET_WALLPAPER_COMPONENT);
|
|
synchronized (mLock) {
|
|
final long ident = Binder.clearCallingIdentity();
|
|
try {
|
|
ServiceInfo si = mContext.getPackageManager().getServiceInfo(name,
|
|
PackageManager.GET_META_DATA | PackageManager.GET_PERMISSIONS);
|
|
if (!android.Manifest.permission.BIND_WALLPAPER.equals(si.permission)) {
|
|
throw new SecurityException("Selected service does not require "
|
|
+ android.Manifest.permission.BIND_WALLPAPER
|
|
+ ": " + name);
|
|
}
|
|
|
|
// Make sure the selected service is actually a wallpaper service.
|
|
Intent intent = new Intent(WallpaperService.SERVICE_INTERFACE);
|
|
List<ResolveInfo> ris = mContext.getPackageManager()
|
|
.queryIntentServices(intent, 0);
|
|
for (int i=0; i<ris.size(); i++) {
|
|
ServiceInfo rsi = ris.get(i).serviceInfo;
|
|
if (rsi.name.equals(si.name) &&
|
|
rsi.packageName.equals(si.packageName)) {
|
|
ris = null;
|
|
break;
|
|
}
|
|
}
|
|
if (ris != null) {
|
|
throw new SecurityException("Selected service is not a wallpaper: "
|
|
+ name);
|
|
}
|
|
|
|
// Bind the service!
|
|
WallpaperConnection newConn = new WallpaperConnection();
|
|
intent.setComponent(name);
|
|
if (!mContext.bindService(intent, newConn,
|
|
Context.BIND_AUTO_CREATE)) {
|
|
throw new IllegalArgumentException("Unable to bind service: "
|
|
+ name);
|
|
}
|
|
|
|
clearWallpaperComponentLocked();
|
|
mWallpaperComponent = null;
|
|
mWallpaperConnection = newConn;
|
|
try {
|
|
if (DEBUG) Log.v(TAG, "Adding window token: " + newConn.mToken);
|
|
mIWindowManager.addWindowToken(newConn.mToken,
|
|
WindowManager.LayoutParams.TYPE_WALLPAPER);
|
|
} catch (RemoteException e) {
|
|
}
|
|
|
|
} catch (PackageManager.NameNotFoundException e) {
|
|
throw new IllegalArgumentException("Unknown component " + name);
|
|
} finally {
|
|
Binder.restoreCallingIdentity(ident);
|
|
}
|
|
}
|
|
}
|
|
|
|
void clearWallpaperComponentLocked() {
|
|
mWallpaperComponent = null;
|
|
if (mWallpaperConnection != null) {
|
|
if (mWallpaperConnection.mEngine != null) {
|
|
try {
|
|
mWallpaperConnection.mEngine.destroy();
|
|
} catch (RemoteException e) {
|
|
}
|
|
}
|
|
mContext.unbindService(mWallpaperConnection);
|
|
mWallpaperConnection = null;
|
|
}
|
|
}
|
|
|
|
void attachServiceLocked(WallpaperConnection conn) {
|
|
try {
|
|
conn.mService.attach(conn, conn.mToken, mWidth, mHeight);
|
|
} catch (RemoteException e) {
|
|
Log.w(TAG, "Failed attaching wallpaper; clearing", e);
|
|
clearWallpaperComponentLocked();
|
|
}
|
|
}
|
|
|
|
private void notifyCallbacksLocked() {
|
|
final int n = mCallbacks.beginBroadcast();
|
|
for (int i = 0; i < n; i++) {
|
|
try {
|
|
mCallbacks.getBroadcastItem(i).onWallpaperChanged();
|
|
} catch (RemoteException e) {
|
|
|
|
// The RemoteCallbackList will take care of removing
|
|
// the dead object for us.
|
|
}
|
|
}
|
|
mCallbacks.finishBroadcast();
|
|
final Intent intent = new Intent(Intent.ACTION_WALLPAPER_CHANGED);
|
|
mContext.sendBroadcast(intent);
|
|
}
|
|
|
|
private void checkPermission(String permission) {
|
|
if (PackageManager.PERMISSION_GRANTED!= mContext.checkCallingOrSelfPermission(permission)) {
|
|
throw new SecurityException("Access denied to process: " + Binder.getCallingPid()
|
|
+ ", must have permission " + permission);
|
|
}
|
|
}
|
|
|
|
private static JournaledFile makeJournaledFile() {
|
|
final String base = "/data/system/wallpaper_info.xml";
|
|
return new JournaledFile(new File(base), new File(base + ".tmp"));
|
|
}
|
|
|
|
private void saveSettingsLocked() {
|
|
JournaledFile journal = makeJournaledFile();
|
|
FileOutputStream stream = null;
|
|
try {
|
|
stream = new FileOutputStream(journal.chooseForWrite(), false);
|
|
XmlSerializer out = new FastXmlSerializer();
|
|
out.setOutput(stream, "utf-8");
|
|
out.startDocument(null, true);
|
|
|
|
out.startTag(null, "wp");
|
|
out.attribute(null, "width", Integer.toString(mWidth));
|
|
out.attribute(null, "height", Integer.toString(mHeight));
|
|
out.attribute(null, "name", mName);
|
|
if (mWallpaperComponent != null) {
|
|
out.attribute(null, "component",
|
|
mWallpaperComponent.flattenToShortString());
|
|
}
|
|
out.endTag(null, "wp");
|
|
|
|
out.endDocument();
|
|
stream.close();
|
|
journal.commit();
|
|
} catch (IOException e) {
|
|
try {
|
|
if (stream != null) {
|
|
stream.close();
|
|
}
|
|
} catch (IOException ex) {
|
|
// Ignore
|
|
}
|
|
journal.rollback();
|
|
}
|
|
}
|
|
|
|
private void loadSettingsLocked() {
|
|
JournaledFile journal = makeJournaledFile();
|
|
FileInputStream stream = null;
|
|
File file = journal.chooseForRead();
|
|
boolean success = false;
|
|
try {
|
|
stream = new FileInputStream(file);
|
|
XmlPullParser parser = Xml.newPullParser();
|
|
parser.setInput(stream, null);
|
|
|
|
int type;
|
|
do {
|
|
type = parser.next();
|
|
if (type == XmlPullParser.START_TAG) {
|
|
String tag = parser.getName();
|
|
if ("wp".equals(tag)) {
|
|
mWidth = Integer.parseInt(parser.getAttributeValue(null, "width"));
|
|
mHeight = Integer.parseInt(parser.getAttributeValue(null, "height"));
|
|
mName = parser.getAttributeValue(null, "name");
|
|
String comp = parser.getAttributeValue(null, "component");
|
|
mWallpaperComponent = comp != null
|
|
? ComponentName.unflattenFromString(comp)
|
|
: null;
|
|
}
|
|
}
|
|
} while (type != XmlPullParser.END_DOCUMENT);
|
|
success = true;
|
|
} catch (NullPointerException e) {
|
|
Log.w(TAG, "failed parsing " + file + " " + e);
|
|
} catch (NumberFormatException e) {
|
|
Log.w(TAG, "failed parsing " + file + " " + e);
|
|
} catch (XmlPullParserException e) {
|
|
Log.w(TAG, "failed parsing " + file + " " + e);
|
|
} catch (IOException e) {
|
|
Log.w(TAG, "failed parsing " + file + " " + e);
|
|
} catch (IndexOutOfBoundsException e) {
|
|
Log.w(TAG, "failed parsing " + file + " " + e);
|
|
}
|
|
try {
|
|
if (stream != null) {
|
|
stream.close();
|
|
}
|
|
} catch (IOException e) {
|
|
// Ignore
|
|
}
|
|
|
|
if (!success) {
|
|
mWidth = -1;
|
|
mHeight = -1;
|
|
mName = "";
|
|
}
|
|
}
|
|
|
|
void settingsRestored() {
|
|
boolean success = false;
|
|
synchronized (mLock) {
|
|
loadSettingsLocked();
|
|
// If there's a wallpaper name, we use that. If that can't be loaded, then we
|
|
// use the default.
|
|
if ("".equals(mName)) {
|
|
success = true;
|
|
} else {
|
|
success = restoreNamedResourceLocked();
|
|
}
|
|
}
|
|
|
|
if (!success) {
|
|
Log.e(TAG, "Failed to restore wallpaper: '" + mName + "'");
|
|
mName = "";
|
|
WALLPAPER_FILE.delete();
|
|
}
|
|
saveSettingsLocked();
|
|
}
|
|
|
|
boolean restoreNamedResourceLocked() {
|
|
if (mName.length() > 4 && "res:".equals(mName.substring(0, 4))) {
|
|
String resName = mName.substring(4);
|
|
|
|
String pkg = null;
|
|
int colon = resName.indexOf(':');
|
|
if (colon > 0) {
|
|
pkg = resName.substring(0, colon);
|
|
}
|
|
|
|
String ident = null;
|
|
int slash = resName.lastIndexOf('/');
|
|
if (slash > 0) {
|
|
ident = resName.substring(slash+1);
|
|
}
|
|
|
|
String type = null;
|
|
if (colon > 0 && slash > 0 && (slash-colon) > 1) {
|
|
type = resName.substring(colon+1, slash);
|
|
}
|
|
|
|
if (pkg != null && ident != null && type != null) {
|
|
int resId = -1;
|
|
InputStream res = null;
|
|
FileOutputStream fos = null;
|
|
try {
|
|
Context c = mContext.createPackageContext(pkg, Context.CONTEXT_RESTRICTED);
|
|
Resources r = c.getResources();
|
|
resId = r.getIdentifier(resName, null, null);
|
|
if (resId == 0) {
|
|
Log.e(TAG, "couldn't resolve identifier pkg=" + pkg + " type=" + type
|
|
+ " ident=" + ident);
|
|
return false;
|
|
}
|
|
|
|
res = r.openRawResource(resId);
|
|
fos = new FileOutputStream(WALLPAPER_FILE);
|
|
|
|
byte[] buffer = new byte[32768];
|
|
int amt;
|
|
while ((amt=res.read(buffer)) > 0) {
|
|
fos.write(buffer, 0, amt);
|
|
}
|
|
// mWallpaperObserver will notice the close and send the change broadcast
|
|
|
|
Log.d(TAG, "Restored wallpaper: " + resName);
|
|
return true;
|
|
} catch (NameNotFoundException e) {
|
|
Log.e(TAG, "Package name " + pkg + " not found");
|
|
} catch (Resources.NotFoundException e) {
|
|
Log.e(TAG, "Resource not found: " + resId);
|
|
} catch (IOException e) {
|
|
Log.e(TAG, "IOException while restoring wallpaper ", e);
|
|
} finally {
|
|
if (res != null) {
|
|
try {
|
|
res.close();
|
|
} catch (IOException ex) {}
|
|
}
|
|
if (fos != null) {
|
|
try {
|
|
fos.close();
|
|
} catch (IOException ex) {}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
}
|