Intel Management Engine BIOS Extention 설정시 암호 변경이 안될 때 해결방법

공대생의 팁 2015. 8. 19. 21:12

 Intel 사의 bios를 설정할 때에 사용되는Intel Management Engine BIOS Extention을 처음 사용할 때에 default 암호를 알 수가 없어 이를 어떻게 해야 헤결될 수 있는지 방법을 한참 찾다 설정 방법을 알게 되어 이렇게 포스팅을 하게 되었습니다. 혹시 Intel Management Engine BIOS Extention을 설정하시다가 저와 같이 암호 설정 때문에 애를 먹는 분이라면 본 포스팅이 도움이 되었으면 합니다.


 먼저, Intel Management Engine BIOS Extention에 진입하는 방법부터 알아보도록 하겠습니다. 아래 화면은 Dell사의 컴퓨터를 기준으로 F12 버튼을 누른 후 Boot Device Menu로 진입한 화면입니다.



 이렇게 Boot Device Menu에 진입하게 되면 위와 같은 메뉴들을 확인하실 수 있습니다. 이 중 Intel Management Engine BIOS Extention을 선택하여 진입하도록 합니다.



 그렇게 해서 진입을 하면 아래에서 보는 바와 같이 처음부터 암호를 입력하라는 뜬금없는 화면이 뜨게 됩니다. 우리는 이 암호를 설정한 적도 없음에도 이렇게 버젓이 뜨니 당혹스러울 수 밖에 없는 상황이지요...

 실은 해당 암호는 처음에는 Defalt로 기본 암호가 설정되어 있습니다. 해당 Default 암호는 다음과 같습니다.


admin


 위의 디폴트 암호를 입력하시면 아래와 같이 암호를 새로 설정하라는 안내가 나옵니다.



 그런데 이상하게도 암호를 설정하려 할 때마다 위와 같은 경고문이 뜨면서 변경된 암호를 받아들이지 않는 당혹스러운 상황이 벌어집니다.


Error - Intel(R) ME password change rejected


 위와 같은 일이 발생하는 이유는 자신이 설정한 암호가 해당 프로그램이 요구하는 암호의 기준에 맞지 않아 보안에 약한 암호이기 때문에 위와 같이 자신이 설정한 암호가 거절당하는 상황이 발생하게 됩니다.

 위와 같은 상황이 생기시는 분들이 계신다면 아래의 규칙대로 자신의 암호를 다시 설정하시면 암호를 설정하실 수 있을 것입니다.


 1. 8자 이상의 암호로 구성되어야 합니다.

 2. 1개 이상의 숫자가 암호에 포함되어야 합니다.(1,2,...,0)

 3. 1개 이상의 기호(!,@,#,$,...)가 포함되어야 합니다. 단, '_'는 암호로 설정할 수 있으나 기호로는 예외입니다.

 4. 알파벳 설정시 대문자와 소문자를 섞어서 사용해야 합니다.



 예를 들어 다음과 같이 암호를 설정하시면 확실하게 적용되는 것을 확인하실 수 있습니다.


eLecs20!5



300x250
저작자표시 (새창열림)

'공대생의 팁' 카테고리의 다른 글

IP v4 주소 0.0.0.0의 의미  (0) 2015.09.27
PHLASHNT.SYS 드라이버를 로드할 수 없습니다. 오류 코드: 1275  (1) 2015.09.07
Ubuntu에서 특정 Unicode가 안보일 때  (0) 2015.07.22
GFDM(Generalized Frequency Domain Multiplexing)  (0) 2015.06.06
TIZEN Native 단계에서 LOG를 활용해보자!  (0) 2015.06.05
,

SurfaceView가 다른 View 클래스와의 차이(updateWindow() method in SurfaceView class)

안드로이드/프레임워크 2015. 8. 17. 20:13

 안드로이드 UI를 설계할 때 주로 사용되는 View의 경우 화면에 한 번 표출되면 특별한 이펙트를 적용하지 않는 한 Activity에서 생성된 모습 그대로의 모습을 유지하는 경우가 대부분입니다.

 반면 SurfaceView의 경우 화면의 변화가 다른 View들에 비해 거의 실시간으로 화면에 변화를 주어야 하는 특성을 가지고 있기 때문에 이를 실시간으로 적용시킬 수 있는 기능이 필요로 하는데 그 중 하나가 updateWindow() 함수입니다.


 아래 간단한 예제를 통해 알아보도록 하겠습니다.


1
surfaceView.setVisibility(View.VISIBLE);
cs


 Application 단계에서 SurfaceView를 화면상에서 보이도록 설정하게 되는 순간 SurfaceView는 화면에 비추어지기 시작합니다.


/frameworks/base/core/java/android/view/SurfaceView.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
    @Override
    public void setVisibility(int visibility) {
        super.setVisibility(visibility);
        mViewVisibility = visibility == VISIBLE;
        boolean newRequestedVisible = mWindowVisibility && mViewVisibility;
        if (newRequestedVisible != mRequestedVisible) {
            // our base class (View) invalidates the layout only when
            // we go from/to the GONE state. However, SurfaceView needs
            // to request a re-layout when the visibility changes at all.
            // This is needed because the transparent region is computed
            // as part of the layout phase, and it changes (obviously) when
            // the visibility changes.
            requestLayout();
        }
        mRequestedVisible = newRequestedVisible;
        updateWindow(false, false);
    }
cs


 보시는 바와 같이 SurfaceView를 화면에 비추도록 설정하였을 때 함수 내에 updateWindow() 함수가 호출되고 있는 것을 보실 수 있습니다. 해당 함수는 SurfaceHolder에서 설정한 기능들을 수행하는 데에 사용되며 SurfaceHolder에 대한 자세한 사항은 아래 포스팅을 참조해 주시길 바랍니다.


http://elecs.tistory.com/78


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
    private void updateWindow(boolean force, boolean redrawNeeded) {
 
        if (!mHaveFrame) {
            return;
        }
        ViewRootImpl viewRoot = getViewRootImpl();
        if (viewRoot != null) {
            mTranslator = viewRoot.mTranslator;
        }
 
        if (mTranslator != null) {
            mSurface.setCompatibilityTranslator(mTranslator);
        }
 
        int myWidth = mRequestedWidth;
        if (myWidth <= 0) myWidth = getWidth();
        int myHeight = mRequestedHeight;
        if (myHeight <= 0) myHeight = getHeight();
 
        getLocationInWindow(mLocation);
        final boolean creating = mWindow == null;
        final boolean formatChanged = mFormat != mRequestedFormat;
        final boolean sizeChanged = mWidth != myWidth || mHeight != myHeight;
        final boolean visibleChanged = mVisible != mRequestedVisible;
 
        if (force || creating || formatChanged || sizeChanged || visibleChanged
            || mLeft != mLocation[0] || mTop != mLocation[1]
            || mUpdateWindowNeeded || mReportDrawNeeded || redrawNeeded) {
 
            if (DEBUG) Log.i(TAG, "Changes: creating=" + creating
                    + " format=" + formatChanged + " size=" + sizeChanged
                    + " visible=" + visibleChanged
                    + " left=" + (mLeft != mLocation[0])
                    + " top=" + (mTop != mLocation[1]));
 
            try {
                final boolean visible = mVisible = mRequestedVisible;
                mLeft = mLocation[0];
                mTop = mLocation[1];
                mWidth = myWidth;
                mHeight = myHeight;
                mFormat = mRequestedFormat;
 
                // Scaling/Translate window's layout here because mLayout is not used elsewhere.
 
                // Places the window relative
                mLayout.x = mLeft;
                mLayout.y = mTop;
                mLayout.width = getWidth();
                mLayout.height = getHeight();
                if (mTranslator != null) {
                    mTranslator.translateLayoutParamsInAppWindowToScreen(mLayout);
                }
 
                mLayout.format = mRequestedFormat;
                mLayout.flags |=WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE
                              | WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE
                              | WindowManager.LayoutParams.FLAG_LAYOUT_NO_LIMITS
                              | WindowManager.LayoutParams.FLAG_SCALED
                              | WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE
                              | WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE
                              ;
                if (!getContext().getResources().getCompatibilityInfo().supportsScreen()) {
                    mLayout.privateFlags |=
                            WindowManager.LayoutParams.PRIVATE_FLAG_COMPATIBLE_WINDOW;
                }
                mLayout.privateFlags |= WindowManager.LayoutParams.PRIVATE_FLAG_NO_MOVE_ANIMATION;
 
                if (mWindow == null) {
                    Display display = getDisplay();
                    mWindow = new MyWindow(this);
                    mLayout.type = mWindowType;
                    mLayout.gravity = Gravity.START|Gravity.TOP;
                    mSession.addToDisplayWithoutInputChannel(mWindow, mWindow.mSeq, mLayout,
                            mVisible ? VISIBLE : GONE, display.getDisplayId(), mContentInsets);
                }
 
                boolean realSizeChanged;
                boolean reportDrawNeeded;
 
                int relayoutResult;
 
                mSurfaceLock.lock();
                try {
                    mUpdateWindowNeeded = false;
                    reportDrawNeeded = mReportDrawNeeded;
                    mReportDrawNeeded = false;
                    mDrawingStopped = !visible;
 
                    if (DEBUG) Log.i(TAG, "Cur surface: " + mSurface);
 
                    relayoutResult = mSession.relayout(
                        mWindow, mWindow.mSeq, mLayout, mWidth, mHeight,
                            visible ? VISIBLE : GONE,
                            WindowManagerGlobal.RELAYOUT_DEFER_SURFACE_DESTROY,
                            mWinFrame, mOverscanInsets, mContentInsets,
                            mVisibleInsets, mConfiguration, mNewSurface);
                    if ((relayoutResult & WindowManagerGlobal.RELAYOUT_RES_FIRST_TIME) != 0) {
                        mReportDrawNeeded = true;
                    }
 
                    if (DEBUG) Log.i(TAG, "New surface: " + mNewSurface
                            + ", vis=" + visible + ", frame=" + mWinFrame);
 
                    mSurfaceFrame.left = 0;
                    mSurfaceFrame.top = 0;
                    if (mTranslator == null) {
                        mSurfaceFrame.right = mWinFrame.width();
                        mSurfaceFrame.bottom = mWinFrame.height();
                    } else {
                        float appInvertedScale = mTranslator.applicationInvertedScale;
                        mSurfaceFrame.right = (int) (mWinFrame.width() * appInvertedScale + 0.5f);
                        mSurfaceFrame.bottom = (int) (mWinFrame.height() * appInvertedScale + 0.5f);
                    }
 
                    final int surfaceWidth = mSurfaceFrame.right;
                    final int surfaceHeight = mSurfaceFrame.bottom;
                    realSizeChanged = mLastSurfaceWidth != surfaceWidth
                            || mLastSurfaceHeight != surfaceHeight;
                    mLastSurfaceWidth = surfaceWidth;
                    mLastSurfaceHeight = surfaceHeight;
                } finally {
                    mSurfaceLock.unlock();
                }
 
                try {
                    redrawNeeded |= creating | reportDrawNeeded;
 
                    SurfaceHolder.Callback callbacks[] = null;
 
                    final boolean surfaceChanged = (relayoutResult
                            & WindowManagerGlobal.RELAYOUT_RES_SURFACE_CHANGED) != 0;
                    if (mSurfaceCreated && (surfaceChanged || (!visible && visibleChanged))) {
                        mSurfaceCreated = false;
                        if (mSurface.isValid()) {
                            if (DEBUG) Log.i(TAG, "visibleChanged -- surfaceDestroyed");
                            callbacks = getSurfaceCallbacks();
                            for (SurfaceHolder.Callback c : callbacks) {
                                c.surfaceDestroyed(mSurfaceHolder);
                            }
                        }
                    }
 
                    mSurface.transferFrom(mNewSurface);
 
                    if (visible && mSurface.isValid()) {
                        if (!mSurfaceCreated && (surfaceChanged || visibleChanged)) {
                            mSurfaceCreated = true;
                            mIsCreating = true;
                            if (DEBUG) Log.i(TAG, "visibleChanged -- surfaceCreated");
                            if (callbacks == null) {
                                callbacks = getSurfaceCallbacks();
                            }
                            for (SurfaceHolder.Callback c : callbacks) {
                                c.surfaceCreated(mSurfaceHolder);
                            }
                        }
                        if (creating || formatChanged || sizeChanged
                                || visibleChanged || realSizeChanged) {
                            if (DEBUG) Log.i(TAG, "surfaceChanged -- format=" + mFormat
                                    + " w=" + myWidth + " h=" + myHeight);
                            if (callbacks == null) {
                                callbacks = getSurfaceCallbacks();
                            }
                            for (SurfaceHolder.Callback c : callbacks) {
                                c.surfaceChanged(mSurfaceHolder, mFormat, myWidth, myHeight);
                            }
                        }
                        if (redrawNeeded) {
                            if (DEBUG) Log.i(TAG, "surfaceRedrawNeeded");
                            if (callbacks == null) {
                                callbacks = getSurfaceCallbacks();
                            }
                            for (SurfaceHolder.Callback c : callbacks) {
                                if (c instanceof SurfaceHolder.Callback2) {
                                    ((SurfaceHolder.Callback2)c).surfaceRedrawNeeded(
                                            mSurfaceHolder);
                                }
                            }
                        }
                    }
                } finally {
                    mIsCreating = false;
                    if (redrawNeeded) {
                        if (DEBUG) Log.i(TAG, "finishedDrawing");
                        mSession.finishDrawing(mWindow);
                    }
                    mSession.performDeferredDestroy(mWindow);
                }
            } catch (RemoteException ex) {
            }
            if (DEBUG) Log.v(
                TAG, "Layout: x=" + mLayout.x + " y=" + mLayout.y +
                " w=" + mLayout.width + " h=" + mLayout.height +
                ", frame=" + mSurfaceFrame);
        }
    }
cs


300x250
저작자표시 (새창열림)

'안드로이드 > 프레임워크' 카테고리의 다른 글

안드로이드 프레임워크 프로그래밍(22) [SurfaceFlinger(시스템 서비스) 등록 및 초기화 과정]  (0) 2015.08.28
안드로이드 프레임워크 프로그래밍(21) [System Service란?]  (0) 2015.08.23
[Android Developers] SurfaceHolder  (0) 2015.08.13
안드로이드 Framework 단계에서 Surface 생성과정  (0) 2015.04.30
Java JNI 코드 분석 : GetObjectClass()  (0) 2015.04.29
,

[Android Developers] SurfaceHolder

안드로이드/프레임워크 2015. 8. 13. 00:38

  SurfaceHolder란 말 그대로 하나의 display surface를 잡고 있는 추상 Interface를 말합니다.  SurfaceHolder는 개발자가 직접 surface의 사이즈나 형식을 조절할 수 있고 surface의 pixel을 수정할 수 있습니다. 그리고 surface의 변화를 실시간으로 확인할 수 있습니다. SurfaceHolder는 왠만해서는 SurfaceView 클래스를 통해 사용할 수 있습니다.


 Surface의 상태 변경에 대한 정보를 다루기 위해서는 SurfaceHolder.Callback 인터페이스를 사용합니다. SurfaceView에서 사용될 때 SurfaceHolder.Callback 내에 있는 surfaceCreated(), surfaceDistroyed() 함수를 설정하는 것으로 Surface를 통제할 수 있게 합니다. SurfaceHolder.Callback는 SurfaceHolder.addCallback() 함수를 통해 등록할 수 있습니다.


SurfaceHolder가 SurfaceView에 적용되는 과정은 아래 포스팅을 참조해 주시길 바랍니다.

http://elecs.tistory.com/78


출저 : http://developer.android.com/reference/android/view/SurfaceHolder.html

300x250
저작자표시 (새창열림)

'안드로이드 > 프레임워크' 카테고리의 다른 글

안드로이드 프레임워크 프로그래밍(21) [System Service란?]  (0) 2015.08.23
SurfaceView가 다른 View 클래스와의 차이(updateWindow() method in SurfaceView class)  (0) 2015.08.17
안드로이드 Framework 단계에서 Surface 생성과정  (0) 2015.04.30
Java JNI 코드 분석 : GetObjectClass()  (0) 2015.04.29
안드로이드 프레임워크 프로그래밍(20) [JNI를 통해 Native에서 JAVA 변수 및 클래스 객체 다루기]  (0) 2015.04.28
,
1 ··· 110 111 112 113 114 115 116 ··· 154

티스토리툴바