i7500 bring camera back from deathTips


Last Updated:

  1. Olavi697

    Olavi697 New Member

    If your camera dead and wish to recover it at try update camera in firmware then visit my thread "i7500 bring camera back from death"

    1: Download 1.2-update-i7500-modacocustomrom-signed.zip extract the zip take out all camera firmware, system/bin/mm-qcamera-test, system/lib/libcamera.so libcamerafirmwarejni.so libcameraservice.so libcm.so, system/firmware/ RS_M4Mo.bin, system/app/ camera.apk camera.odex camerafirmware.apk camerafirmware.odex and place them on the phone in the same folders they are in.

    1: It doesnt matter wich firmware you have when you do this they will be there when you update camera firmware.

    http://www.findthatzipfile.com/sear...2-update-i7500-modacocustomrom-signed.zip.htm

    + create and put Android.mk in folder system/lib, The following stub Android.mk file ensures that libcamera compiles and links to the appropriate libraries:

    1:1: Android.mk contains:

    LOCAL_PATH := $(call my-dir)
    include $(CLEAR_VARS)

    LOCAL_MODULE := libcamera

    LOCAL_SHARED_LIBRARIES := \
    libutils \
    librpc \
    liblog

    LOCAL_SRC_FILES += MyCameraHardware.cpp

    LOCAL_CFLAGS +=

    LOCAL_C_INCLUDES +=

    LOCAL_STATIC_LIBRARIES += \
    libcamera-common \
    libclock-rpc \
    libcommondefs-rpc

    include $(BUILD_SHARED_LIBRARY)

    1:2: And put android.hardware.camera.autofocus.xml in system/permissions folder, and that contains:


    00001 /*
    00002 * Copyright (C) 2008 The Android Open Source Project
    00003 *
    00004 * Licensed under the Apache License, Version 2.0 (the "License");
    00005 * you may not use this file except in compliance with the License.
    00006 * You may obtain a copy of the License at
    00007 *
    00008 * http://www.apache.org/licenses/LICENSE-2.0
    00009 *
    00010 * Unless required by applicable law or agreed to in writing, software
    00011 * distributed under the License is distributed on an "AS IS" BASIS,
    00012 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    00013 * See the License for the specific language governing permissions and
    00014 * limitations under the License.
    00015 */
    00016
    00017 #ifndef ANDROID_HARDWARE_CAMERA_HARDWARE_INTERFACE_H
    00018 #define ANDROID_HARDWARE_CAMERA_HARDWARE_INTERFACE_H
    00019
    00020 #include <utils/IMemory.h>
    00021 #include <utils/RefBase.h>
    00022 #include <ui/CameraParameters.h>
    00023 #include <ui/Overlay.h>
    00024
    00025 namespace android {
    00026
    00027 /** Callback for startPreview() */
    00028 typedef void (*preview_callback)(const sp<IMemory>& mem, void* user);
    00029
    00030 /** Callback for startRecord() */
    00031 typedef void (*recording_callback)(nsecs_t timestamp, const sp<IMemory>& mem, void* user);
    00032
    00033 /** Callback for takePicture() */
    00034 typedef void (*shutter_callback)(void* user);
    00035
    00036 /** Callback for takePicture() */
    00037 typedef void (*raw_callback)(const sp<IMemory>& mem, void* user);
    00038
    00039 /** Callback for takePicture() */
    00040 typedef void (*jpeg_callback)(const sp<IMemory>& mem, void* user);
    00041
    00042 /** Callback for autoFocus() */
    00043 typedef void (*autofocus_callback)(bool focused, void* user);
    00044
    00045 /**
    00046 * CameraHardwareInterface.h defines the interface to the
    00047 * camera hardware abstraction layer, used for setting and getting
    00048 * parameters, live previewing, and taking pictures.
    00049 *
    00050 * It is a referenced counted interface with RefBase as its base class.
    00051 * CameraService calls openCameraHardware() to retrieve a strong pointer to the
    00052 * instance of this interface and may be called multiple times. The
    00053 * following steps describe a typical sequence:
    00054 *
    00055 * -# After CameraService calls openCameraHardware(), getParameters() and
    00056 * setParameters() are used to initialize the camera instance.
    00057 * CameraService calls getPreviewHeap() to establish access to the
    00058 * preview heap so it can be registered with SurfaceFlinger for
    00059 * efficient display updating while in preview mode.
    00060 * -# startPreview() is called, which is passed a preview_callback()
    00061 * function and a user parameter. The camera instance then periodically
    00062 * calls preview_callback() each time a new preview frame is available.
    00063 * The callback routine has two parameters: the first is a pointer to
    00064 * the IMemory containing the frame and the second a user parameter. If
    00065 * the preview_callback code needs to use this memory after returning,
    00066 * it must copy the data.
    00067 *
    00068 * Prior to taking a picture, CameraService calls autofocus() with
    00069 * autofocus_callback() and a user parameter. When auto focusing has
    00070 * completed, the camera instance calls autofocus_callback(), which informs
    00071 * the application whether focusing was successful. The camera instance
    00072 * only calls autofocus_callback() once and it is up to the application to
    00073 * call autoFocus() again if refocusing is desired.
    00074 *
    00075 * CameraService calls takePicture() to request the camera instance take a
    00076 * picture. This method has two callbacks: raw_callback() and jpeg_callback().
    00077 * When the raw image is available, raw_callback() is called with a pointer
    00078 * to the IMemory containing the raw image. When the jpeg image is available,
    00079 * jpeg_callback() is called with a pointer to the IMemory containing the
    00080 * jpeg image. As with preview_callback(), the memory must be copied if it's
    00081 * needed after returning.
    00082 */
    00083 class CameraHardwareInterface : public virtual RefBase {
    00084 public:
    00085 virtual ~CameraHardwareInterface() { }
    00086
    00087 /** Return the IMemoryHeap for the preview image heap */
    00088 virtual sp<IMemoryHeap> getPreviewHeap() const = 0;
    00089
    00090 /** Return the IMemoryHeap for the raw image heap */
    00091 virtual sp<IMemoryHeap> getRawHeap() const = 0;
    00092
    00093 /**
    00094 * Start preview mode. When a preview image is available
    00095 * preview_callback is called with the user parameter. The
    00096 * call back parameter may be null.
    00097 */
    00098 virtual status_t startPreview(preview_callback cb, void* user) = 0;
    00099 /**
    00100 * Only used if overlays are used for camera preview.
    00101 */
    00102 virtual bool useOverlay() {return false;}
    00103 virtual status_t setOverlay(const sp<Overlay> &overlay) {return BAD_VALUE;}
    00104
    00105 /**
    00106 * Stop a previously started preview.
    00107 */
    00108 virtual void stopPreview() = 0;
    00109
    00110 /**
    00111 * Returns true if preview is enabled.
    00112 */
    00113 virtual bool previewEnabled() = 0;
    00114
    00115 /**
    00116 * Start record mode. When a record image is available recording_callback()
    00117 * is called with the user parameter. Every record frame must be released
    00118 * by calling releaseRecordingFrame().
    00119 */
    00120 virtual status_t startRecording(recording_callback cb, void* user) = 0;
    00121
    00122 /**
    00123 * Stop a previously started recording.
    00124 */
    00125 virtual void stopRecording() = 0;
    00126
    00127 /**
    00128 * Returns true if recording is enabled.
    00129 */
    00130 virtual bool recordingEnabled() = 0;
    00131
    00132 /**
    00133 * Release a record frame previously returned by the recording_callback()
    00134 * passed to startRecord().
    00135 */
    00136 virtual void releaseRecordingFrame(const sp<IMemory>& mem) = 0;
    00137
    00138 /**
    00139 * Start auto focus, the callback routine is called
    00140 * once when focusing is complete. autoFocus() will
    00141 * be called again if another auto focus is needed.
    00142 */
    00143 virtual status_t autoFocus(autofocus_callback,
    00144 void* user) = 0;
    00145
    00146 /**
    00147 * Take a picture. The raw_callback is called when
    00148 * the uncompressed image is available. The jpeg_callback
    00149 * is called when the compressed image is available. These
    00150 * call backs may be null. The user parameter is passed
    00151 * to each of the call back routines.
    00152 */
    00153 virtual status_t takePicture(shutter_callback,
    00154 raw_callback,
    00155 jpeg_callback,
    00156 void* user) = 0;
    00157
    00158 /**
    00159 * Cancel a picture that was started with takePicture. You may cancel any
    00160 * of the shutter, raw, or jpeg callbacks. Calling this method when no
    00161 * picture is being taken is a no-op.
    00162 */
    00163 virtual status_t cancelPicture(bool cancel_shutter,
    00164 bool cancel_raw,
    00165 bool cancel_jpeg) = 0;
    00166
    00167 /** Set the camera parameters. */
    00168 virtual status_t setParameters(const CameraParameters& params) = 0;
    00169
    00170 /** Return the camera parameters. */
    00171 virtual CameraParameters getParameters() const = 0;
    00172
    00173 /**
    00174 * Release the hardware resources owned by this object. Note that this is
    00175 * *not* done in the destructor.
    00176 */
    00177 virtual void release() = 0;
    00178
    00179 /**
    00180 * Dump state of the camera hardware
    00181 */
    00182 virtual status_t dump(int fd, const Vector<String16>& args) const = 0;
    00183 };
    00184
    00185 /** factory function to instantiate a camera hardware object */
    00186 extern "C" sp<CameraHardwareInterface> openCameraHardware();
    00187
    00188 }; // namespace android
    00189
    00190 #endif



    2: Download Odin Multi Downloader v3.95 with orion.ops

    3: Download I7500XXII5-PDA-CL64494-REV5(VIA).tar flash via odin.

    Incoerentemente

    Advertisement
  2. Frisco

    Frisco =Luceat Lux Vestra= VIP Member

    Thank you for sharing that, Olavi! :) Welcome to Android Forums.

    I'm sure that users who have a need for that will proceed with great care through all of the steps you provided.
  3. tomline

    tomline New Member

    Hello, it looks good but I can not download the file. It does not longer exist on this link. Is there an other way to get it?

    Thx , Tom

Share This Page