1/*
2 * Copyright (C) 2010 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17/**
18 * @addtogroup NativeActivity Native Activity
19 * @{
20 */
21
22/**
23 * @file native_window.h
24 */
25
26#ifndef ANDROID_NATIVE_WINDOW_H
27#define ANDROID_NATIVE_WINDOW_H
28
29#include <android/rect.h>
30
31#ifdef __cplusplus
32extern "C" {
33#endif
34
35/**
36 * Pixel formats that a window can use.
37 */
38enum {
39    /** Red: 8 bits, Green: 8 bits, Blue: 8 bits, Alpha: 8 bits. **/
40    WINDOW_FORMAT_RGBA_8888          = 1,
41    /** Red: 8 bits, Green: 8 bits, Blue: 8 bits, Unused: 8 bits. **/
42    WINDOW_FORMAT_RGBX_8888          = 2,
43    /** Red: 5 bits, Green: 6 bits, Blue: 5 bits. **/
44    WINDOW_FORMAT_RGB_565            = 4,
45};
46
47struct ANativeWindow;
48/**
49 * {@link ANativeWindow} is opaque type that provides access to a native window.
50 *
51 * A pointer can be obtained using ANativeWindow_fromSurface().
52 */
53typedef struct ANativeWindow ANativeWindow;
54
55/**
56 * {@link ANativeWindow} is a struct that represents a windows buffer.
57 *
58 * A pointer can be obtained using ANativeWindow_lock().
59 */
60typedef struct ANativeWindow_Buffer {
61    // The number of pixels that are show horizontally.
62    int32_t width;
63
64    // The number of pixels that are shown vertically.
65    int32_t height;
66
67    // The number of *pixels* that a line in the buffer takes in
68    // memory.  This may be >= width.
69    int32_t stride;
70
71    // The format of the buffer.  One of WINDOW_FORMAT_*
72    int32_t format;
73
74    // The actual bits.
75    void* bits;
76
77    // Do not touch.
78    uint32_t reserved[6];
79} ANativeWindow_Buffer;
80
81/**
82 * Acquire a reference on the given ANativeWindow object.  This prevents the object
83 * from being deleted until the reference is removed.
84 */
85void ANativeWindow_acquire(ANativeWindow* window);
86
87/**
88 * Remove a reference that was previously acquired with ANativeWindow_acquire().
89 */
90void ANativeWindow_release(ANativeWindow* window);
91
92/**
93 * Return the current width in pixels of the window surface.  Returns a
94 * negative value on error.
95 */
96int32_t ANativeWindow_getWidth(ANativeWindow* window);
97
98/**
99 * Return the current height in pixels of the window surface.  Returns a
100 * negative value on error.
101 */
102int32_t ANativeWindow_getHeight(ANativeWindow* window);
103
104/**
105 * Return the current pixel format of the window surface.  Returns a
106 * negative value on error.
107 */
108int32_t ANativeWindow_getFormat(ANativeWindow* window);
109
110/**
111 * Change the format and size of the window buffers.
112 *
113 * The width and height control the number of pixels in the buffers, not the
114 * dimensions of the window on screen.  If these are different than the
115 * window's physical size, then it buffer will be scaled to match that size
116 * when compositing it to the screen.
117 *
118 * For all of these parameters, if 0 is supplied then the window's base
119 * value will come back in force.
120 *
121 * width and height must be either both zero or both non-zero.
122 *
123 */
124int32_t ANativeWindow_setBuffersGeometry(ANativeWindow* window,
125        int32_t width, int32_t height, int32_t format);
126
127/**
128 * Lock the window's next drawing surface for writing.
129 * inOutDirtyBounds is used as an in/out parameter, upon entering the
130 * function, it contains the dirty region, that is, the region the caller
131 * intends to redraw. When the function returns, inOutDirtyBounds is updated
132 * with the actual area the caller needs to redraw -- this region is often
133 * extended by ANativeWindow_lock.
134 */
135int32_t ANativeWindow_lock(ANativeWindow* window, ANativeWindow_Buffer* outBuffer,
136        ARect* inOutDirtyBounds);
137
138/**
139 * Unlock the window's drawing surface after previously locking it,
140 * posting the new buffer to the display.
141 */
142int32_t ANativeWindow_unlockAndPost(ANativeWindow* window);
143
144#ifdef __cplusplus
145};
146#endif
147
148#endif // ANDROID_NATIVE_WINDOW_H
149
150/** @} */
151