国民游戏王者荣耀的真实地图开发之路

public class UnityPlayerNativeActivity extends NativeActivity  
{ 
    protected UnityPlayer mUnityPlayer; // don't change the name of this variable; referenced from native code 
    // Setup activity layout 
    @Override protected void onCreate (Bundle savedInstanceState)  
    { 
        requestWindowFeature(Window.FEATURE_NO_TITLE); 
        super.onCreate(savedInstanceState); 
        getWindow().takeSurface(null); 
        setTheme(android.R.style.Theme_NoTitleBar_Fullscreen); 
        getWindow().setFormat(PixelFormat.RGB_565); 
        mUnityPlayer = new UnityPlayer(this); 
        if (mUnityPlayer.getSettings ().getBoolean ("hide_status_bar", true)) 
            getWindow ().setFlags (WindowManager.LayoutParams.FLAG_FULLSCREEN, 
                                   WindowManager.LayoutParams.FLAG_FULLSCREEN); 
  
        setContentView(mUnityPlayer); 
        mUnityPlayer.requestFocus(); 
    } 
    ..............................
}

ViewGroup rootView = (ViewGroup)activity.getWindow().getDecorView();
ViewGroup.LayoutParams param = new ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT,ViewGroup.LayoutParams.MATCH_PARENT); 
rootView.addView(mView, param);

/**
 * 获取场景挂载点 (keyWindow)
 * @return 挂载点
 */
+ (UIView *)getMountPoint{
    UIWindow *window = [UIApplication sharedApplication].keyWindow;
    NSAssert(window != nil, @"window must not be nil");
    return window;
}
/**
 * 挂载到 keywindow.
 */
- (void)mount{
    UIView *mountPoint = [[self class] getMountPoint];
    NSAssert([self underlyingView].superview == nil , @"scene super view must be nil");
    [mountPoint addSubview:[self underlyingView]];
}

private SurfaceView n; 
public class UnityPlayer extends FrameLayout implements
    com.unity3d.player.a.aaa {
  public UnityPlayer(final ContextWrapper m) {
  super((Context) m);
        this.n = new SurfaceView((Context) m);
  this.n.getHolder().addCallback((SurfaceHolder.Callback) new SurfaceHolder.Callback() {
          public final void surfaceCreated{
          //缺省**************************
          }
          public final void surfaceChanged{
            //缺省**************************
          }
          public final void surfaceDestroyed（final SurfaceHolder surfaceHolder) {
//缺省**************************
                                        }
        });
    this.n.setFocusable(true);
    this.n.setFocusableInTouchMode(true);
                //缺省**************************
          }
}

struct UKLabel {
    // View通用属性
    0 require UKInt id; //唯一标示
    1 optional UKInt zIndex;//z轴索引
    2 require UKRect rect;//显示区域，坐标，宽高
    3 optional UKBool invisible;//是否隐藏
    4 optional UKColor backgroundColor;//背景色
    
    // 文本属性.
    5 optional UKString text; //文本
    6 optional UKColor textColor; //文本颜色
    7 optional UKColor highlightedTextColor;//高亮时的颜色
    8 optional UKFont font;//字体
    9 optional UKTextAlignment textAlignment;//文本位置，居中，居左等
    10 optional UKEllipsis ellipsis;//文本省略方式
  };

class UKLabel{
   /**
     设置文本
   */
   public void setText(UKString text){
     if(text != null){
          setText(text.getval())
     }
   }
}

UKLabel label = new UKLabel();
label.setText("hello world");

/**
     * 对外调用接口
     * @param target
     * 消息目标，jce格式化后的数据
     * @param method
     * 数据参数，jce格式化后的数据
     * */
    public void call(byte[] target, byte[] method);

struct UKCallbackTarget {
  
  0 require UKInt targetID;//回调时间的id
  
  1 require UKTargetType targetType;//回调的对象类型 如：Button，TableView
  
  2 require UKCallbackType callbackType;//回调数据类型，如点击或者状态变化
};

struct UKTableViewCallbackData_Clicked {
  0 require UKInt idx; //被点击的item的index
};

/**
     * 回调，目前支持点击回调，或者事件回调
     * @param target
     * 回调事件对象
     * @param @data
     * 回调事件数据
     * */
    public void callback(byte[] target, byte[] data);

size: {
  width: {
    val: 1280
  }
  height: {
    val: 720
  }
}

WindowManager wm = this.getWindowManager();
ScreenUtils.width = wm.getDefaultDisplay().getWidth();
ScreenUtils.height = wm.getDefaultDisplay().getHeight();

<meta-data android:name="android.app.lib_name" android:value="unity" /> 
<meta-data android:name="unityplayer.ForwardNativeEventsToDalvik" android:value="true" />

WindowManager wm = this.getWindowManager();
ScreenUtils.width = wm.getDefaultDisplay().getWidth();
ScreenUtils.height = wm.getDefaultDisplay().getHeight();

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }

    @Override
    public void onWindowFocusChanged(boolean hasFocus) {
        super.onWindowFocusChanged(hasFocus);
        if (hasFocus && Build.VERSION.SDK_INT >= 19) {
            View decorView = getWindow().getDecorView();
            decorView.setSystemUiVisibility(
                View.SYSTEM_UI_FLAG_LAYOUT_STABLE
                | View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION
                | View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN
                | View.SYSTEM_UI_FLAG_HIDE_NAVIGATION
                | View.SYSTEM_UI_FLAG_FULLSCREEN
                | View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY);
        }
    }

}

WindowManager windowManager = activity.getWindowManager();
            if (mScene.getParent() != null) {
                windowManager.removeView(mScene);
            }
            try {
                windowManager.addView(mScene, params);
            } catch (WindowManager.BadTokenException e) {
                e.printStackTrace();
            } catch (WindowManager.InvalidDisplayException e) {
                e.printStackTrace();
            }

public WindowManager.LayoutParams createLayoutParams(int left, int top, int width, int height) {
        WindowManager.LayoutParams windowParams = new WindowManager.LayoutParams();
        windowParams.gravity = Gravity.LEFT | Gravity.TOP;
        windowParams.flags = windowParams.flags
                | WindowManager.LayoutParams.FLAG_IGNORE_CHEEK_PRESSES
                | WindowManager.LayoutParams.FLAG_NOT_TOUCH_MODAL
                | WindowManager.LayoutParams.FLAG_LAYOUT_IN_SCREEN
                | WindowManager.LayoutParams.FLAG_HARDWARE_ACCELERATED
                | WindowManager.LayoutParams.FLAG_FULLSCREEN
                | WindowManager.LayoutParams.FLAG_TRANSLUCENT_STATUS
                | WindowManager.LayoutParams.FLAG_TRANSLUCENT_NAVIGATION;
        windowParams.width = width;
        windowParams.height = height;
        windowParams.x = left;
        windowParams.y = top;
        windowParams.format = PixelFormat.TRANSLUCENT;
        windowParams.softInputMode |= WindowManager.LayoutParams.SOFT_INPUT_IS_FORWARD_NAVIGATION;
        if (mActivityReference.get() != null) {
            windowParams.type = WindowManager.LayoutParams.TYPE_APPLICATION;
        } else {
            windowParams.type = WindowManager.LayoutParams.TYPE_SYSTEM_ALERT;
        }
        windowParams.systemUiVisibility = View.SYSTEM_UI_FLAG_HIDE_NAVIGATION;

        return windowParams;
    }

WindowManager.LayoutParams.FLAG_TRANSLUCENT_NAVIGATION;

windowParams.systemUiVisibility = View.SYSTEM_UI_FLAG_HIDE_NAVIGATION;

/**
     * Create drawable from raw nine-patch data, setting initial target density
     * based on the display metrics of the resources.
     */
    public NinePatchDrawable(Resources res, Bitmap bitmap, byte[] chunk,
            Rect padding, String srcName) {
        this(new NinePatchState(new NinePatch(bitmap, chunk, srcName), padding), res);
    }

// NinePatch chunk.
class NinePatchChunk {

    public static final int NO_COLOR = 0x00000001;
    public static final int TRANSPARENT_COLOR = 0x00000000;

    public Rect mPaddings = new Rect();

    public int mDivX[];
    public int mDivY[];
    public int mColor[];

    private static void readIntArray(int[] data, ByteBuffer buffer) {
        for (int i = 0, n = data.length; i < n; ++i) {
            data[i] = buffer.getInt();
        }
    }

    private static void checkDivCount(int length) {
        if (length == 0 || (length & 0x01) != 0) {
            throw new RuntimeException("invalid nine-patch: " + length);
        }
    }

    public static NinePatchChunk deserialize(byte[] data) {
        ByteBuffer byteBuffer =
                ByteBuffer.wrap(data).order(ByteOrder.nativeOrder());

        byte wasSerialized = byteBuffer.get();
        if (wasSerialized == 0) return null;

        NinePatchChunk chunk = new NinePatchChunk();
        chunk.mDivX = new int[byteBuffer.get()];
        chunk.mDivY = new int[byteBuffer.get()];
        chunk.mColor = new int[byteBuffer.get()];

        checkDivCount(chunk.mDivX.length);
        checkDivCount(chunk.mDivY.length);

        // skip 8 bytes
        byteBuffer.getInt();
        byteBuffer.getInt();

        chunk.mPaddings.left = byteBuffer.getInt();
        chunk.mPaddings.right = byteBuffer.getInt();
        chunk.mPaddings.top = byteBuffer.getInt();
        chunk.mPaddings.bottom = byteBuffer.getInt();

        // skip 4 bytes
        byteBuffer.getInt();

        readIntArray(chunk.mDivX, byteBuffer);
        readIntArray(chunk.mDivY, byteBuffer);
        readIntArray(chunk.mColor, byteBuffer);

        return chunk;
    }
}

public class NinePatchBitmapFactory {

    // The 9 patch segment is not a solid color.
    private static final int NO_COLOR = 0x00000001;

    // The 9 patch segment is completely transparent.
    private static final int TRANSPARENT_COLOR = 0x00000000;

    public static NinePatchDrawable createNinePathWithCapInsets(Resources res, Bitmap bitmap, int top, int left, int bottom, int right, String srcName) {
        ByteBuffer buffer = getByteBuffer(top, left, bottom, right);
        NinePatchDrawable drawable = new NinePatchDrawable(res, bitmap, buffer.array(), new Rect(), srcName);
        return drawable;
    }

    public static NinePatch createNinePatch(Resources res, Bitmap bitmap, int top, int left, int bottom, int right, String srcName) {
        ByteBuffer buffer = getByteBuffer(top, left, bottom, right);
        NinePatch patch = new NinePatch(bitmap, buffer.array(), srcName);
        return patch;
    }

    private static ByteBuffer getByteBuffer(int top, int left, int bottom, int right) {
        //Docs check the NinePatchChunkFile
        ByteBuffer buffer = ByteBuffer.allocate(56).order(ByteOrder.nativeOrder());
        //was translated
        buffer.put((byte)0x01);
        //divx size
        buffer.put((byte)0x02);
        //divy size
        buffer.put((byte)0x02);
        //color size
        buffer.put(( byte)0x02);

        //skip
        buffer.putInt(0);
        buffer.putInt(0);

        //padding
        buffer.putInt(0);
        buffer.putInt(0);
        buffer.putInt(0);
        buffer.putInt(0);

        //skip 4 bytes
        buffer.putInt(0);

        buffer.putInt(left);
        buffer.putInt(right);
        buffer.putInt(top);
        buffer.putInt(bottom);
        buffer.putInt(NO_COLOR);
        buffer.putInt(NO_COLOR);

        return buffer;
    }

}

/**
     * Set the density scale at which this drawable will be rendered. This
     * method assumes the drawable will be rendered at the same density as the
     * specified canvas.
     *
     * @param canvas The Canvas from which the density scale must be obtained.
     *
     * @see android.graphics.Bitmap#setDensity(int)
     * @see android.graphics.Bitmap#getDensity()
     */
    public void setTargetDensity(@NonNull Canvas canvas) {
        setTargetDensity(canvas.getDensity());
    }

    /**
     * Set the density scale at which this drawable will be rendered.
     *
     * @param metrics The DisplayMetrics indicating the density scale for this drawable.
     *
     * @see android.graphics.Bitmap#setDensity(int)
     * @see android.graphics.Bitmap#getDensity()
     */
    public void setTargetDensity(@NonNull DisplayMetrics metrics) {
        setTargetDensity(metrics.densityDpi);
    }

    /**
     * Set the density at which this drawable will be rendered.
     *
     * @param density The density scale for this drawable.
     *
     * @see android.graphics.Bitmap#setDensity(int)
     * @see android.graphics.Bitmap#getDensity()
     */
    public void setTargetDensity(int density) {
        if (density == 0) {
            density = DisplayMetrics.DENSITY_DEFAULT;
        }

        if (mTargetDensity != density) {
            mTargetDensity = density;

            computeBitmapSize();
            invalidateSelf();
        }
    }

@Override
    public void draw(Canvas canvas) {
        final NinePatchState state = mNinePatchState;

        Rect bounds = getBounds();
        int restoreToCount = -1;

        final boolean clearColorFilter;
        if (mTintFilter != null && getPaint().getColorFilter() == null) {
            mPaint.setColorFilter(mTintFilter);
            clearColorFilter = true;
        } else {
            clearColorFilter = false;
        }

        final int restoreAlpha;
        if (state.mBaseAlpha != 1.0f) {
            restoreAlpha = getPaint().getAlpha();
            mPaint.setAlpha((int) (restoreAlpha * state.mBaseAlpha + 0.5f));
        } else {
            restoreAlpha = -1;
        }

        final boolean needsDensityScaling = canvas.getDensity() == 0;
        if (needsDensityScaling) {
            restoreToCount = restoreToCount >= 0 ? restoreToCount : canvas.save();

            // Apply density scaling.
            final float scale = mTargetDensity / (float) state.mNinePatch.getDensity();
            final float px = bounds.left;
            final float py = bounds.top;
            canvas.scale(scale, scale, px, py);

            if (mTempRect == null) {
                mTempRect = new Rect();
            }

            // Scale the bounds to match.
            final Rect scaledBounds = mTempRect;
            scaledBounds.left = bounds.left;
            scaledBounds.top = bounds.top;
            scaledBounds.right = bounds.left + Math.round(bounds.width() / scale);
            scaledBounds.bottom = bounds.top + Math.round(bounds.height() / scale);
            bounds = scaledBounds;
        }

        final boolean needsMirroring = needsMirroring();
        if (needsMirroring) {
            restoreToCount = restoreToCount >= 0 ? restoreToCount : canvas.save();

            // Mirror the 9patch.
            final float cx = (bounds.left + bounds.right) / 2.0f;
            final float cy = (bounds.top + bounds.bottom) / 2.0f;
            canvas.scale(-1.0f, 1.0f, cx, cy);
        }

        state.mNinePatch.draw(canvas, bounds, mPaint);

        if (restoreToCount >= 0) {
            canvas.restoreToCount(restoreToCount);
        }

        if (clearColorFilter) {
            mPaint.setColorFilter(null);
        }

        if (restoreAlpha >= 0) {
            mPaint.setAlpha(restoreAlpha);
        }
    }

float density = (context.getResources().getDisplayMetrics().density);
       
 Bitmap scaledBitmap = Bitmap.createScaledBitmap(bitmap, (int)(bitmap.getWidth() * density), (int)(bitmap.getHeight() * density), true);
        
 ByteBuffer buffer = getByteBufferFixed((int)(top * density), (int)(left * density), (int)(bottom * density), (int)(right * density));
 NinePatchDrawable drawable = new NinePatchDrawable(context.getResources(), scaledBitmap, buffer.array(), new Rect(), null);