mirror of
https://github.com/dragonpilot/dragonpilot.git
synced 2026-02-23 12:33:52 +08:00
openpilot v0.6 release
This commit is contained in:
Vehicle Researcher
@@ -0,0 +1,42 @@
|
||||
/*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
// All static variables go here, to control initialization and
|
||||
// destruction order in the library.
|
||||
|
||||
#include <utils/threads.h>
|
||||
|
||||
#include <binder/IBinder.h>
|
||||
#include <binder/IMemory.h>
|
||||
#include <binder/ProcessState.h>
|
||||
#include <binder/IPermissionController.h>
|
||||
#include <binder/IServiceManager.h>
|
||||
|
||||
namespace android {
|
||||
|
||||
// For TextStream.cpp
|
||||
extern Vector<int32_t> gTextBuffers;
|
||||
|
||||
// For ProcessState.cpp
|
||||
extern Mutex gProcessMutex;
|
||||
extern sp<ProcessState> gProcess;
|
||||
|
||||
// For IServiceManager.cpp
|
||||
extern Mutex gDefaultServiceManagerLock;
|
||||
extern sp<IServiceManager> gDefaultServiceManager;
|
||||
extern sp<IPermissionController> gPermissionController;
|
||||
|
||||
} // namespace android
|
||||
@@ -0,0 +1,33 @@
|
||||
/*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
#ifndef _BINDER_MODULE_H_
|
||||
#define _BINDER_MODULE_H_
|
||||
|
||||
#ifdef __cplusplus
|
||||
namespace android {
|
||||
#endif
|
||||
|
||||
/* obtain structures and constants from the kernel header */
|
||||
|
||||
#include <sys/ioctl.h>
|
||||
#include <linux/binder.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
} // namespace android
|
||||
#endif
|
||||
|
||||
#endif // _BINDER_MODULE_H_
|
||||
@@ -0,0 +1,62 @@
|
||||
/*
|
||||
* Copyright (C) 2011 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_PRIVATE_GUI_COMPOSER_SERVICE_H
|
||||
#define ANDROID_PRIVATE_GUI_COMPOSER_SERVICE_H
|
||||
|
||||
#include <stdint.h>
|
||||
#include <sys/types.h>
|
||||
|
||||
#include <utils/Singleton.h>
|
||||
#include <utils/StrongPointer.h>
|
||||
|
||||
|
||||
namespace android {
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
class IMemoryHeap;
|
||||
class ISurfaceComposer;
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
// This holds our connection to the composer service (i.e. SurfaceFlinger).
|
||||
// If the remote side goes away, we will re-establish the connection.
|
||||
// Users of this class should not retain the value from
|
||||
// getComposerService() for an extended period.
|
||||
//
|
||||
// (It's not clear that using Singleton is useful here anymore.)
|
||||
class ComposerService : public Singleton<ComposerService>
|
||||
{
|
||||
sp<ISurfaceComposer> mComposerService;
|
||||
sp<IBinder::DeathRecipient> mDeathObserver;
|
||||
Mutex mLock;
|
||||
|
||||
ComposerService();
|
||||
void connectLocked();
|
||||
void composerServiceDied();
|
||||
friend class Singleton<ComposerService>;
|
||||
public:
|
||||
|
||||
// Get a connection to the Composer Service. This will block until
|
||||
// a connection is established.
|
||||
static sp<ISurfaceComposer> getComposerService();
|
||||
};
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
}; // namespace android
|
||||
|
||||
#endif // ANDROID_PRIVATE_GUI_COMPOSER_SERVICE_H
|
||||
@@ -0,0 +1,143 @@
|
||||
/*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
#ifndef ANDROID_SF_LAYER_STATE_H
|
||||
#define ANDROID_SF_LAYER_STATE_H
|
||||
|
||||
#include <stdint.h>
|
||||
#include <sys/types.h>
|
||||
|
||||
#include <utils/Errors.h>
|
||||
|
||||
#include <ui/Region.h>
|
||||
#include <ui/Rect.h>
|
||||
|
||||
namespace android {
|
||||
|
||||
class Parcel;
|
||||
class ISurfaceComposerClient;
|
||||
|
||||
/*
|
||||
* Used to communicate layer information between SurfaceFlinger and its clients.
|
||||
*/
|
||||
struct layer_state_t {
|
||||
|
||||
|
||||
enum {
|
||||
eLayerHidden = 0x01, // SURFACE_HIDDEN in SurfaceControl.java
|
||||
eLayerOpaque = 0x02, // SURFACE_OPAQUE
|
||||
eLayerSecure = 0x80, // SECURE
|
||||
};
|
||||
|
||||
enum {
|
||||
ePositionChanged = 0x00000001,
|
||||
eLayerChanged = 0x00000002,
|
||||
eSizeChanged = 0x00000004,
|
||||
eAlphaChanged = 0x00000008,
|
||||
eMatrixChanged = 0x00000010,
|
||||
eTransparentRegionChanged = 0x00000020,
|
||||
eFlagsChanged = 0x00000040,
|
||||
eLayerStackChanged = 0x00000080,
|
||||
eCropChanged = 0x00000100,
|
||||
eBlurChanged = 0x00400000,
|
||||
eBlurMaskSurfaceChanged = 0x00800000,
|
||||
eBlurMaskSamplingChanged = 0x01000000,
|
||||
eBlurMaskAlphaThresholdChanged = 0x02000000,
|
||||
};
|
||||
|
||||
layer_state_t()
|
||||
: what(0),
|
||||
x(0), y(0), z(0), w(0), h(0), layerStack(0), blur(0),
|
||||
blurMaskSampling(0), blurMaskAlphaThreshold(0), alpha(0), flags(0), mask(0),
|
||||
reserved(0)
|
||||
{
|
||||
matrix.dsdx = matrix.dtdy = 1.0f;
|
||||
matrix.dsdy = matrix.dtdx = 0.0f;
|
||||
crop.makeInvalid();
|
||||
}
|
||||
|
||||
status_t write(Parcel& output) const;
|
||||
status_t read(const Parcel& input);
|
||||
|
||||
struct matrix22_t {
|
||||
float dsdx;
|
||||
float dtdx;
|
||||
float dsdy;
|
||||
float dtdy;
|
||||
};
|
||||
sp<IBinder> surface;
|
||||
uint32_t what;
|
||||
float x;
|
||||
float y;
|
||||
uint32_t z;
|
||||
uint32_t w;
|
||||
uint32_t h;
|
||||
uint32_t layerStack;
|
||||
float blur;
|
||||
sp<IBinder> blurMaskSurface;
|
||||
uint32_t blurMaskSampling;
|
||||
float blurMaskAlphaThreshold;
|
||||
float alpha;
|
||||
uint8_t flags;
|
||||
uint8_t mask;
|
||||
uint8_t reserved;
|
||||
matrix22_t matrix;
|
||||
Rect crop;
|
||||
// non POD must be last. see write/read
|
||||
Region transparentRegion;
|
||||
};
|
||||
|
||||
struct ComposerState {
|
||||
sp<ISurfaceComposerClient> client;
|
||||
layer_state_t state;
|
||||
status_t write(Parcel& output) const;
|
||||
status_t read(const Parcel& input);
|
||||
};
|
||||
|
||||
struct DisplayState {
|
||||
|
||||
enum {
|
||||
eOrientationDefault = 0,
|
||||
eOrientation90 = 1,
|
||||
eOrientation180 = 2,
|
||||
eOrientation270 = 3,
|
||||
eOrientationUnchanged = 4,
|
||||
eOrientationSwapMask = 0x01
|
||||
};
|
||||
|
||||
enum {
|
||||
eSurfaceChanged = 0x01,
|
||||
eLayerStackChanged = 0x02,
|
||||
eDisplayProjectionChanged = 0x04,
|
||||
eDisplaySizeChanged = 0x08
|
||||
};
|
||||
|
||||
uint32_t what;
|
||||
sp<IBinder> token;
|
||||
sp<IGraphicBufferProducer> surface;
|
||||
uint32_t layerStack;
|
||||
uint32_t orientation;
|
||||
Rect viewport;
|
||||
Rect frame;
|
||||
uint32_t width, height;
|
||||
status_t write(Parcel& output) const;
|
||||
status_t read(const Parcel& input);
|
||||
};
|
||||
|
||||
}; // namespace android
|
||||
|
||||
#endif // ANDROID_SF_LAYER_STATE_H
|
||||
|
||||
@@ -0,0 +1,45 @@
|
||||
/*
|
||||
* 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_GUI_SYNC_FEATURES_H
|
||||
#define ANDROID_GUI_SYNC_FEATURES_H
|
||||
|
||||
#include <utils/Singleton.h>
|
||||
#include <utils/String8.h>
|
||||
|
||||
|
||||
namespace android {
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
class SyncFeatures : public Singleton<SyncFeatures> {
|
||||
friend class Singleton<SyncFeatures>;
|
||||
bool mHasNativeFenceSync;
|
||||
bool mHasFenceSync;
|
||||
bool mHasWaitSync;
|
||||
String8 mString;
|
||||
SyncFeatures();
|
||||
|
||||
public:
|
||||
bool useNativeFenceSync() const;
|
||||
bool useFenceSync() const;
|
||||
bool useWaitSync() const;
|
||||
String8 toString() const;
|
||||
};
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
}; // namespace android
|
||||
|
||||
#endif // ANDROID_GUI_SYNC_FEATURES_H
|
||||
@@ -0,0 +1,301 @@
|
||||
/*
|
||||
* Copyright (C) 2009 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_UI_PRIVATE_REGION_HELPER_H
|
||||
#define ANDROID_UI_PRIVATE_REGION_HELPER_H
|
||||
|
||||
#include <stdint.h>
|
||||
#include <sys/types.h>
|
||||
|
||||
namespace android {
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
template<typename RECT>
|
||||
class region_operator
|
||||
{
|
||||
public:
|
||||
typedef typename RECT::value_type TYPE;
|
||||
static const TYPE max_value = 0x7FFFFFF;
|
||||
|
||||
/*
|
||||
* Common boolean operations:
|
||||
* value is computed as 0b101 op 0b110
|
||||
* other boolean operation are possible, simply compute
|
||||
* their corresponding value with the above formulae and use
|
||||
* it when instantiating a region_operator.
|
||||
*/
|
||||
static const uint32_t LHS = 0x5; // 0b101
|
||||
static const uint32_t RHS = 0x6; // 0b110
|
||||
enum {
|
||||
op_nand = LHS & ~RHS,
|
||||
op_and = LHS & RHS,
|
||||
op_or = LHS | RHS,
|
||||
op_xor = LHS ^ RHS
|
||||
};
|
||||
|
||||
struct region {
|
||||
RECT const* rects;
|
||||
size_t count;
|
||||
TYPE dx;
|
||||
TYPE dy;
|
||||
inline region(const region& rhs)
|
||||
: rects(rhs.rects), count(rhs.count), dx(rhs.dx), dy(rhs.dy) { }
|
||||
inline region(RECT const* r, size_t c)
|
||||
: rects(r), count(c), dx(), dy() { }
|
||||
inline region(RECT const* r, size_t c, TYPE dx, TYPE dy)
|
||||
: rects(r), count(c), dx(dx), dy(dy) { }
|
||||
};
|
||||
|
||||
class region_rasterizer {
|
||||
friend class region_operator;
|
||||
virtual void operator()(const RECT& rect) = 0;
|
||||
public:
|
||||
virtual ~region_rasterizer() { };
|
||||
};
|
||||
|
||||
inline region_operator(int op, const region& lhs, const region& rhs)
|
||||
: op_mask(op), spanner(lhs, rhs)
|
||||
{
|
||||
}
|
||||
|
||||
void operator()(region_rasterizer& rasterizer) {
|
||||
RECT current;
|
||||
do {
|
||||
SpannerInner spannerInner(spanner.lhs, spanner.rhs);
|
||||
int inside = spanner.next(current.top, current.bottom);
|
||||
spannerInner.prepare(inside);
|
||||
do {
|
||||
TYPE left, right;
|
||||
int inside = spannerInner.next(current.left, current.right);
|
||||
if ((op_mask >> inside) & 1) {
|
||||
if (current.left < current.right &&
|
||||
current.top < current.bottom) {
|
||||
rasterizer(current);
|
||||
}
|
||||
}
|
||||
} while(!spannerInner.isDone());
|
||||
} while(!spanner.isDone());
|
||||
}
|
||||
|
||||
private:
|
||||
uint32_t op_mask;
|
||||
|
||||
class SpannerBase
|
||||
{
|
||||
public:
|
||||
SpannerBase()
|
||||
: lhs_head(max_value), lhs_tail(max_value),
|
||||
rhs_head(max_value), rhs_tail(max_value) {
|
||||
}
|
||||
|
||||
enum {
|
||||
lhs_before_rhs = 0,
|
||||
lhs_after_rhs = 1,
|
||||
lhs_coincide_rhs = 2
|
||||
};
|
||||
|
||||
protected:
|
||||
TYPE lhs_head;
|
||||
TYPE lhs_tail;
|
||||
TYPE rhs_head;
|
||||
TYPE rhs_tail;
|
||||
|
||||
inline int next(TYPE& head, TYPE& tail,
|
||||
bool& more_lhs, bool& more_rhs)
|
||||
{
|
||||
int inside;
|
||||
more_lhs = false;
|
||||
more_rhs = false;
|
||||
if (lhs_head < rhs_head) {
|
||||
inside = lhs_before_rhs;
|
||||
head = lhs_head;
|
||||
if (lhs_tail <= rhs_head) {
|
||||
tail = lhs_tail;
|
||||
more_lhs = true;
|
||||
} else {
|
||||
lhs_head = rhs_head;
|
||||
tail = rhs_head;
|
||||
}
|
||||
} else if (rhs_head < lhs_head) {
|
||||
inside = lhs_after_rhs;
|
||||
head = rhs_head;
|
||||
if (rhs_tail <= lhs_head) {
|
||||
tail = rhs_tail;
|
||||
more_rhs = true;
|
||||
} else {
|
||||
rhs_head = lhs_head;
|
||||
tail = lhs_head;
|
||||
}
|
||||
} else {
|
||||
inside = lhs_coincide_rhs;
|
||||
head = lhs_head;
|
||||
if (lhs_tail <= rhs_tail) {
|
||||
tail = rhs_head = lhs_tail;
|
||||
more_lhs = true;
|
||||
}
|
||||
if (rhs_tail <= lhs_tail) {
|
||||
tail = lhs_head = rhs_tail;
|
||||
more_rhs = true;
|
||||
}
|
||||
}
|
||||
return inside;
|
||||
}
|
||||
};
|
||||
|
||||
class Spanner : protected SpannerBase
|
||||
{
|
||||
friend class region_operator;
|
||||
region lhs;
|
||||
region rhs;
|
||||
|
||||
public:
|
||||
inline Spanner(const region& lhs, const region& rhs)
|
||||
: lhs(lhs), rhs(rhs)
|
||||
{
|
||||
if (lhs.count) {
|
||||
SpannerBase::lhs_head = lhs.rects->top + lhs.dy;
|
||||
SpannerBase::lhs_tail = lhs.rects->bottom + lhs.dy;
|
||||
}
|
||||
if (rhs.count) {
|
||||
SpannerBase::rhs_head = rhs.rects->top + rhs.dy;
|
||||
SpannerBase::rhs_tail = rhs.rects->bottom + rhs.dy;
|
||||
}
|
||||
}
|
||||
|
||||
inline bool isDone() const {
|
||||
return !rhs.count && !lhs.count;
|
||||
}
|
||||
|
||||
inline int next(TYPE& top, TYPE& bottom)
|
||||
{
|
||||
bool more_lhs = false;
|
||||
bool more_rhs = false;
|
||||
int inside = SpannerBase::next(top, bottom, more_lhs, more_rhs);
|
||||
if (more_lhs) {
|
||||
advance(lhs, SpannerBase::lhs_head, SpannerBase::lhs_tail);
|
||||
}
|
||||
if (more_rhs) {
|
||||
advance(rhs, SpannerBase::rhs_head, SpannerBase::rhs_tail);
|
||||
}
|
||||
return inside;
|
||||
}
|
||||
|
||||
private:
|
||||
static inline
|
||||
void advance(region& reg, TYPE& aTop, TYPE& aBottom) {
|
||||
// got to next span
|
||||
size_t count = reg.count;
|
||||
RECT const * rects = reg.rects;
|
||||
RECT const * const end = rects + count;
|
||||
const int top = rects->top;
|
||||
while (rects != end && rects->top == top) {
|
||||
rects++;
|
||||
count--;
|
||||
}
|
||||
if (rects != end) {
|
||||
aTop = rects->top + reg.dy;
|
||||
aBottom = rects->bottom + reg.dy;
|
||||
} else {
|
||||
aTop = max_value;
|
||||
aBottom = max_value;
|
||||
}
|
||||
reg.rects = rects;
|
||||
reg.count = count;
|
||||
}
|
||||
};
|
||||
|
||||
class SpannerInner : protected SpannerBase
|
||||
{
|
||||
region lhs;
|
||||
region rhs;
|
||||
|
||||
public:
|
||||
inline SpannerInner(const region& lhs, const region& rhs)
|
||||
: lhs(lhs), rhs(rhs)
|
||||
{
|
||||
}
|
||||
|
||||
inline void prepare(int inside) {
|
||||
if (inside == SpannerBase::lhs_before_rhs) {
|
||||
if (lhs.count) {
|
||||
SpannerBase::lhs_head = lhs.rects->left + lhs.dx;
|
||||
SpannerBase::lhs_tail = lhs.rects->right + lhs.dx;
|
||||
}
|
||||
SpannerBase::rhs_head = max_value;
|
||||
SpannerBase::rhs_tail = max_value;
|
||||
} else if (inside == SpannerBase::lhs_after_rhs) {
|
||||
SpannerBase::lhs_head = max_value;
|
||||
SpannerBase::lhs_tail = max_value;
|
||||
if (rhs.count) {
|
||||
SpannerBase::rhs_head = rhs.rects->left + rhs.dx;
|
||||
SpannerBase::rhs_tail = rhs.rects->right + rhs.dx;
|
||||
}
|
||||
} else {
|
||||
if (lhs.count) {
|
||||
SpannerBase::lhs_head = lhs.rects->left + lhs.dx;
|
||||
SpannerBase::lhs_tail = lhs.rects->right + lhs.dx;
|
||||
}
|
||||
if (rhs.count) {
|
||||
SpannerBase::rhs_head = rhs.rects->left + rhs.dx;
|
||||
SpannerBase::rhs_tail = rhs.rects->right + rhs.dx;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
inline bool isDone() const {
|
||||
return SpannerBase::lhs_head == max_value &&
|
||||
SpannerBase::rhs_head == max_value;
|
||||
}
|
||||
|
||||
inline int next(TYPE& left, TYPE& right)
|
||||
{
|
||||
bool more_lhs = false;
|
||||
bool more_rhs = false;
|
||||
int inside = SpannerBase::next(left, right, more_lhs, more_rhs);
|
||||
if (more_lhs) {
|
||||
advance(lhs, SpannerBase::lhs_head, SpannerBase::lhs_tail);
|
||||
}
|
||||
if (more_rhs) {
|
||||
advance(rhs, SpannerBase::rhs_head, SpannerBase::rhs_tail);
|
||||
}
|
||||
return inside;
|
||||
}
|
||||
|
||||
private:
|
||||
static inline
|
||||
void advance(region& reg, TYPE& left, TYPE& right) {
|
||||
if (reg.rects && reg.count) {
|
||||
const int cur_span_top = reg.rects->top;
|
||||
reg.rects++;
|
||||
reg.count--;
|
||||
if (!reg.count || reg.rects->top != cur_span_top) {
|
||||
left = max_value;
|
||||
right = max_value;
|
||||
} else {
|
||||
left = reg.rects->left + reg.dx;
|
||||
right = reg.rects->right + reg.dx;
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
Spanner spanner;
|
||||
};
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
};
|
||||
|
||||
#endif /* ANDROID_UI_PRIVATE_REGION_HELPER_H */
|
||||
Reference in New Issue
Block a user