ADHOC/replicant-frameworks_native
3
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

am 62fbb163: Shelve InputFlinger for another release. DO NOT MERGE

Browse Source 
* commit '62fbb16383d6d8268821f947e2c6d0828f7e2b41':
  Shelve InputFlinger for another release. DO NOT MERGE
This commit is contained in:
Michael Wright 2014-08-19 01:33:52 +00:00 committed by Android Git Automerger
commit 5a7ad73bd2
7 changed files with 1 additions and 301 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

54
include/input/IInputFlinger.h
View File

@ -1,54 +0,0 @@
/*
* Copyright (C) 2013 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.
*/
#ifndef _LIBINPUT_IINPUT_FLINGER_H
#define _LIBINPUT_IINPUT_FLINGER_H
#include <stdint.h>
#include <sys/types.h>
#include <binder/IInterface.h>
namespace android {
/*
* This class defines the Binder IPC interface for accessing various
* InputFlinger features.
*/
class IInputFlinger : public IInterface {
public:
DECLARE_META_INTERFACE(InputFlinger);
virtual status_t doSomething() = 0;
};
/**
* Binder implementation.
*/
class BnInputFlinger : public BnInterface<IInputFlinger> {
public:
enum {
DO_SOMETHING_TRANSACTION = IBinder::FIRST_CALL_TRANSACTION,
};
virtual status_t onTransact(uint32_t code, const Parcel& data,
Parcel* reply, uint32_t flags = 0);
};
} // namespace android
#endif // _LIBINPUT_IINPUT_FLINGER_H

1
libs/input/Android.mk
View File

@ -27,7 +27,6 @@ commonSources := \
deviceSources := \
$(commonSources) \
IInputFlinger.cpp \
InputTransport.cpp \
VelocityControl.cpp \
VelocityTracker.cpp

59
libs/input/IInputFlinger.cpp
View File

@ -1,59 +0,0 @@
/*
* Copyright (C) 2013 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.
*/
#include <stdint.h>
#include <sys/types.h>
#include <binder/Parcel.h>
#include <binder/IPCThreadState.h>
#include <binder/IServiceManager.h>
#include <input/IInputFlinger.h>
namespace android {
class BpInputFlinger : public BpInterface<IInputFlinger> {
public:
BpInputFlinger(const sp<IBinder>& impl) :
BpInterface<IInputFlinger>(impl) { }
virtual status_t doSomething() {
Parcel data, reply;
data.writeInterfaceToken(IInputFlinger::getInterfaceDescriptor());
remote()->transact(BnInputFlinger::DO_SOMETHING_TRANSACTION, data, &reply);
return reply.readInt32();
}
};
IMPLEMENT_META_INTERFACE(InputFlinger, "android.input.IInputFlinger");
status_t BnInputFlinger::onTransact(
uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) {
switch(code) {
case DO_SOMETHING_TRANSACTION: {
CHECK_INTERFACE(IInputFlinger, data, reply);
reply->writeInt32(0);
break;
}
default:
return BBinder::onTransact(code, data, reply, flags);
}
return NO_ERROR;
}
};

19
services/inputflinger/Android.mk
View File

@ -22,8 +22,7 @@ LOCAL_SRC_FILES:= \
InputListener.cpp \
InputManager.cpp \
InputReader.cpp \
InputWindow.cpp \
InputFlinger.cpp
InputWindow.cpp
LOCAL_SHARED_LIBRARIES := \
libbinder \
@ -49,19 +48,3 @@ LOCAL_EXPORT_C_INCLUDE_DIRS := $(LOCAL_PATH)
LOCAL_MODULE := libinputflinger
include $(BUILD_SHARED_LIBRARY)
########################################################################
# build input flinger executable
include $(CLEAR_VARS)
LOCAL_SRC_FILES:= \
main.cpp
LOCAL_SHARED_LIBRARIES := \
libbinder \
libinputflinger \
libutils
LOCAL_MODULE := inputflinger
include $(BUILD_EXECUTABLE)

89
services/inputflinger/InputFlinger.cpp
View File

@ -1,89 +0,0 @@
/*
* Copyright (C) 2013 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.
*/
#define LOG_TAG "InputFlinger"
#include "InputFlinger.h"
#include <stdint.h>
#include <unistd.h>
#include <sys/types.h>
#include <binder/IPCThreadState.h>
#include <binder/PermissionCache.h>
#include <cutils/log.h>
#include <private/android_filesystem_config.h>
namespace android {
const String16 sAccessInputFlingerPermission("android.permission.ACCESS_INPUT_FLINGER");
const String16 sDumpPermission("android.permission.DUMP");
InputFlinger::InputFlinger() :
BnInputFlinger() {
ALOGI("InputFlinger is starting");
}
InputFlinger::~InputFlinger() {
}
status_t InputFlinger::onTransact(
uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) {
switch (code) {
case DO_SOMETHING_TRANSACTION:
const IPCThreadState* ipc = IPCThreadState::self();
const int pid = ipc->getCallingPid();
const int uid = ipc->getCallingUid();
if (!PermissionCache::checkPermission(sAccessInputFlingerPermission, pid, uid)) {
ALOGE("Permission Denial: "
"can't access InputFlinger from pid=%d, uid=%d", pid, uid);
return PERMISSION_DENIED;
}
break;
}
return BnInputFlinger::onTransact(code, data, reply, flags);
}
status_t InputFlinger::dump(int fd, const Vector<String16>& args) {
String8 result;
const IPCThreadState* ipc = IPCThreadState::self();
const int pid = ipc->getCallingPid();
const int uid = ipc->getCallingUid();
if ((uid != AID_SHELL)
&& !PermissionCache::checkPermission(sDumpPermission, pid, uid)) {
result.appendFormat("Permission Denial: "
"can't dump SurfaceFlinger from pid=%d, uid=%d\n", pid, uid);
} else {
dumpInternal(result);
}
write(fd, result.string(), result.size());
return OK;
}
void InputFlinger::dumpInternal(String8& result) {
result.append("INPUT FLINGER (dumpsys inputflinger)\n");
result.append("... nothing here yet...\n");
}
status_t InputFlinger::doSomething() {
ALOGI("Did something...");
return OK;
}
}; // namespace android

54
services/inputflinger/InputFlinger.h
View File

@ -1,54 +0,0 @@
/*
* Copyright (C) 2013 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.
*/
#ifndef ANDROID_INPUT_FLINGER_H
#define ANDROID_INPUT_FLINGER_H
#include <stdint.h>
#include <sys/types.h>
#include <cutils/compiler.h>
#include <input/IInputFlinger.h>
#include <utils/String8.h>
#include <utils/String16.h>
namespace android {
class InputFlinger : public BnInputFlinger {
public:
static char const* getServiceName() ANDROID_API {
return "inputflinger";
}
InputFlinger() ANDROID_API;
// IBinder interface
virtual status_t onTransact(uint32_t code,
const Parcel& data, Parcel* reply, uint32_t flags);
virtual status_t dump(int fd, const Vector<String16>& args);
// IInputFlinger interface
virtual status_t doSomething();
private:
virtual ~InputFlinger();
void dumpInternal(String8& result);
};
} // namespace android
#endif // ANDROID_INPUT_FLINGER_H

26
services/inputflinger/main.cpp
View File

@ -1,26 +0,0 @@
/*
* Copyright (C) 2013 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.
*/
#include <binder/BinderService.h>
#include "InputFlinger.h"
using namespace android;
int main(int, char**) {
ProcessState::self()->setThreadPoolMaxThreadCount(4);
BinderService<InputFlinger>::publishAndJoinThreadPool(true);
return 0;
}