Memory Card Recording

Recording to a memory card is a basic feature for smart cameras. This feature stores the audio, video, and image to the memory card in the specified directory and file structure, allowing for video search, playback, download, and deletion through the mobile app.

A connection to the peer-to-peer (P2P) channel is required before playback. Once the P2P channel is established, users can search for video clips on the camera’s memory card by time frame and play them. For more information, see Memory Card Management.

How it works

Core methods

Important notes

• Do not create two ThingSmartCameraType objects for the same device simultaneously to prevent resource errors.

• During live streaming, you can switch to recording playback without disconnecting and reconnecting the P2P connection. However, you must stop live streaming before querying the video clips on the specified date. Otherwise, there might be flickering issues with the live streaming and recording playback screens. This can also occur when switching from recording playback to live streaming.

• In the following scenarios, query the video clips on the specified date before playing them to avoid problems.

  • After stopping the recording playback, switch to live streaming and then return to playback.
  • After reconnecting to the previously lost P2P channel, start the recording playback.

Core code

Create a ThingSmartCameraType object

+ (id<ThingSmartCameraType>)cameraWithP2PType:(id)type deviceId:(NSString *)devId delegate:(id<ThingSmartCameraDelegate>)delegate;

- (void)cameraInitFailed:(ThingSmartCameraErrorCode)errorCode;

Connect

- (void)connectWithMode:(ThingSmartCameraConnectMode)mode;

- (void)cameraDidConnected:(id<ThingSmartCameraType>)camera;

Query the dates when recordings exist in the specified month and year

- (void)queryRecordDaysWithYear:(NSUInteger)year month:(NSUInteger)month;

- (void)camera:(id<ThingSmartCameraType>)camera didReceiveRecordDayQueryData:(NSArray<NSNumber *> *)days;

Query video clips on the specified date

- (void)queryRecordTimeSliceWithYear:(NSUInteger)year month:(NSUInteger)month day:(NSUInteger)day;

- (void)camera:(id<ThingSmartCameraType>)camera didReceiveTimeSliceQueryData:(NSArray<NSDictionary *> *)timeSlices;

Start playback

- (void)startPlayback:(NSInteger)playTime startTime:(NSInteger)startTime stopTime:(NSInteger)stopTime;

- (void)cameraDidBeginPlayback:(id<ThingSmartCameraType>)camera;

Stop playback

- (void)stopPlayback;

- (void)cameraDidStopPlayback:(id<ThingSmartCameraType>)camera;

Playback completion callback

- (void)camera:(id<ThingSmartCameraType>)camera playbackTimeSlice:(NSDictionary *)timeSlice didFinishedWithStatus:(NSInteger)status;

Playback error

- (void)camera:(id<ThingSmartCameraType>)camera didOccurredErrorAtStep:(ThingCameraErrorCode)errStepCode specificErrorCode:(NSInteger)errorCode;

Disconnect

- (int)disConnect;

Example

//1. Create a ThingSmartCameraType object
- (void)cameraInit {
    // Initialize the device
    self.device = [ThingSmartDevice deviceWithDeviceId:devId];

    // delegate: ThingSmartCameraDelegate   Used to monitor the connection status of P2P channels
    self.camera = [ThingSmartCameraFactory     cameraWithP2PType:@(self.device.deviceModel.p2pType)     deviceId:self.device.deviceModel.devId delegate:self];

    // Initialize video preview page
    self.videoView = self.camera.videoView;

    // Add the video rendering view to the screen
   [self.view addSubview:self.videoView];
}

//2. Connect
- (void)cameraConnect {
    [self.camera connectWithMode:ThingSmartCameraConnectAuto];
}
// Connection successful
- (void)cameraDidConnected:(id<ThingSmartCameraType>)camera {
    self.connected = YES;
      // After the P2P connection is successful, query video footage for a specific day, with the date provided as needed.
     [self queryRecordDaysWithYear:self.year month:self.month];
}
// Connection failed
- (void)cameraDisconnected:(id<ThingSmartCameraType>)camera specificErrorCode:(NSInteger)errorCode {
    // P2P is passively disconnected, usually caused by network jitter.
    self.connected = NO;
}

//3. Query the dates in a specific year and month when video recordings were saved.
- (void)queryRecordDaysWithYear:(NSUInteger)year month:(NSUInteger)month {
    [self.camera queryRecordDaysWithYear:year month:month];
}
// Query callback
- (void)camera:(id<ThingSmartCameraType>)camera didReceiveRecordDayQueryData:(NSArray<NSNumber *> *)days {
    NSString *key = [NSString stringWithFormat:@"%ld-%ld", self.year, self.month];
    NSMutableDictionary *playbackDays = [self.playbackDaysInMonth mutableCopy];
    [playbackDays setObject:days forKey:key];
    self.playbackDaysInMonth = playbackDays;
    // If `days` is empty, there are no recordings.
    if (days.count == 0) {
        return;
    }
    [self queryRecordTimeSliceWithYear:self.year month:self.month day:[days.firstObject integerValue]];
}

//4. Query recordings for a specified date.
- (void)queryRecordTimeSliceWithYear:(NSUInteger)year month:(NSUInteger)month day:(NSUInteger)day {
    [self.camera queryRecordTimeSliceWithYear:year month:month day:day];
}
// Query callback
- (void)camera:(id<ThingSmartCameraType>)camera didReceiveTimeSliceQueryData:(NSArray<NSDictionary *> *)timeSlices {
    // If there is no recording for the day, no video will paly.
    if (timeSlices.count == 0) {
        return;
    }
    // Save the video recording list and start playing from the first one.
    self.timeSlicesInCurrentDay = [timeSlices copy];
    self.timeSlicesIndex = 0;
    NSDictionary *timeSlice = timeSlices.firstObject;
    NSInteger startTime = [timeSlice[kThingSmartTimeSliceStartTime] integerValue];
    NSInteger stopTime = [timeSlice[kThingSmartTimeSliceStopTime] integerValue];
      // Start playing from the first second of the first video clip.
    NSInteger playTime = startTime;
    [self startPlayback:playTime startTime:startTime stopTime:stopTime];
}

//5. Start playback
- (void)startPlayback:(NSInteger)playTime startTime:(NSInteger)startTime stopTime:(NSInteger)stopTime {
    [self.camera startPlayback:playTime startTime:startTime stopTime:stopTime];
}
// The callback for starting playback
- (void)cameraDidBeginPlayback:(id<ThingSmartCameraType>)camera {
      // The video playback starts.
    self.playbacking = YES;
    self.playbackPaused = NO;
}

//6. Stop playback
- (void)stopPlayback {
    [self.camera stopPlayback];
}

- (void)cameraDidStopPlayback:(id<ThingSmartCameraType>)camera {
    self.playbacking = NO;
    self.playbackPaused = NO;
}

//7. Disconnect
- (void)disconnect {
    [self.camera disConnect];
}

#pragma mark - ThingSmartCameraDelegate

- (void)camera:(id<ThingSmartCameraType>)camera thing_didReceiveVideoFrame:(CMSampleBufferRef)sampleBuffer frameInfo:(ThingSmartVideoFrameInfo)frameInfo {
    NSInteger index = self.timeSlicesIndex + 1;
      // If there is no next video recording, then return.
    if (index >= self.timeSlicesInCurrentDay.count) {
        return;
    }
    NSDictionary *currentTimeSlice = [self.timeSlicesInCurrentDay objectAtIndex:self.timeSlicesIndex];
    NSInteger stopTime = [currentTimeSlice[kThingSmartTimeSliceStopTime] integerValue];
      // If the timestamp of the current video frame is greater than or equal to the end time of the current video clip, then play the next video clip.
    if (frameInfo.nTimeStamp >= stopTime) {
        NSDictionary *nextTimeSlice = [self.timeSlicesInCurrentDay objectAtIndex:index];
        NSInteger startTime = [nextTimeSlice[kThingSmartTimeSliceStartTime] integerValue];
            NSInteger stopTime = [nextTimeSlice[kThingSmartTimeSliceStopTime] integerValue];
            NSInteger playTime = startTime;
            [self startPlayback:playTime startTime:startTime stopTime:stopTime];
    }
}

- (void)cameraPlaybackDidFinished:(id<ThingSmartCameraType>)camera {
      // The video playback ends.
    self.playbacking = NO;
    self.playbackPaused = NO;
}

// Error callback
- (void)camera:(id<ThingSmartCameraType>)camera didOccurredErrorAtStep:(ThingCameraErrorCode)errStepCode specificErrorCode:(NSInteger)errorCode extErrorCodeInfo:(id<ThingSmartCameraExtErrorCodeInfo>)extErrorCodeInfo {
        if (errStepCode == Thing_ERROR_CONNECT_FAILED) {
          // P2P connection failed
        self.connected = NO;
    }
    else if (errStepCode == Thing_ERROR_START_PLAYBACK_FAILED) {
          // Failed to play video from the memory card
        self.playbacking = NO;
        self.playbackPaused = NO;
    }
}